Free junit software for mac

OCUnit is a testing framework for Objective C in the MacOSX and WebObjects environment. It is based on SUnit, Kent Becks Smalltalk testing framework, also available for Java under the name JUnit.
With OCUnit, testing becomes integrated with development. You can test frameworks, bundles, or applications.
OCUnit is distributed as open source.
Main features:
- SenTestingKit, a framework to help you write test cases;
- otest, a testing tool;
- a collection of Makefiles and utilities to seamlessly integrate testing with Xcode and ProjectBuilder
- Object-oriented tests.
- Very low overhead.
- Tests are in the same language as the implementation.
- Test case classes cohabit with classes they test.
- Promotes aggressive refactoring.
- Helps capture requirements, expose dependencies.
- Total integration in the development process.
- Records testing expertise.
- Tests frameworks, bundles, or applications.
- Easy installation
- No license fee.
Enhancements:
- Make sure Foundation is loaded before SenTestingKit.
- Added autorelease pool to detect over-releases faster.
- Added license to all source files.

ObjcUnit is a unit testing framework for Objective-C on Mac OS X. Its design was copied from JUnit, written by Erich Gamma and Kent Beck, and then adapted somewhat for Objective-C.

TestKit shares much of the functionality of JUnit, and it adds functionality to help programmers with the problems and challenges unique to Objective-C.

TestKit is an adaptation of JUnit for Objective-C and the Mac OS X development environment.

Benefits:

• Plain English specifications: Rather than forcing product owners to specify requirements in a specially structured language, Concordion lets you write them in plain English using paragraphs, tables and proper punctuation. This makes the specifications much more natural to read and write, and helps everyone to understand and agree about what a feature is supposed to do.
• Always bang up-to-date: Concordion specifications are active. Behind the scenes, they are linked to the system under test and therefore do not go out-of-date. If a change is made to the system's behaviour then the tests associated with the relevant specification will fail and let you know.
• Complex behaviours can be decomposed: Each question at the bottom of the specification links to another active specification and so on until you have either run out of questions or the answer is "Out of Scope". In this way, a complex behaviour can be broken down into small, focused and easily understood requirements.

Major Features:

1. Powerful, yet simple to use: Concordion integrates directly with JUnit.
2. Highly readable tests: Concordion acceptance tests are so readable they can double up as system documentation. And, since the tests are linked to the system, you know the documentation is always up-to-date.
3. Separates tests from implementation: Tests that include a lot of implementation detail lock you into that implementation. Concordion helps you to document the logic and behavior of your system in a way that does not lock you in.

Requirements: Java 1.5 or later

Google Web Toolkit (GWT) is an open source Java software development framework that makes writing AJAX applications like Google Maps and Gmail easy for developers who dont speak browser quirks as a second language.
Writing dynamic web applications today is a tedious and error-prone process; you spend 90% of your time working around subtle incompatibilities between web browsers and platforms, and JavaScripts lack of modularity makes sharing, testing, and reusing AJAX components difficult and fragile.
GWT helps you avoid many of these headaches while offering your users the same dynamic, standards-compliant experience. You write your front end in the Java programming language, and the GWT compiler converts your Java classes to browser-compliant JavaScript and HTML.

Main features:
- Create a Widget by compositing other Widgets. Lay out Widgets automatically in Panels. Send your Widget to other developers in a JAR file.
- To communicate from your web application to your web server, you just need to define serializable Java classes for your request and response. In production, GWT automatically serializes the request and deserializes the response from the server. GWTs RPC mechanism can even handle polymorphic class hierarchies, and you can throw exceptions across the wire.
- No, AJAX applications dont need to break the browsers back button. GWT lets you make your site more usable by easily adding state to the browsers back button history.
- In production, your code is compiled to JavaScript, but at development time it runs in the Java virtual machine. That means when your code performs an action like handling a mouse event, you get full-featured Java debugging, with exceptions and the advanced debugging features of IDEs like Eclipse.
- Your GWT applications automatically support IE, Firefox, Mozilla, Safari, and Opera with no browser detection or special-casing within your code in most cases.
- GWTs direct integration with JUnit lets you unit test both in a debugger and in a browser...and you can even unit test asynchronous RPCs.
- Easily create efficient internationalized applications and libraries.
- If GWTs class library doesnt meet your needs, you can mix handwritten JavaScript in your Java source code using our JavaScript Native Interface (JSNI).
- We are in the process of building support for using Google APIs in GWT applications. Initially, we are providing support for Google Gears, the recently-launched developer product that extends the browser to allow developers to make web-based applications function even while offline. If you would like to download this library please visit the open source project. We are planning to add support for other Google APIs; if youd like to help, please check out Making GWT Better.
- All of the code for GWT is available under the Apache 2.0 license. If you are interested in contributing, please visit Making GWT Better.

Enhancements
Fixed Issues:
- The classpath in the scripts created by junitCreator was updated to refer to /war/WEB-INF/classes rather than /bin.

Given an accessible database schema, the Hibernate POJO Generator produces all the Java code necessary to access each field in each table via the Hibernate persistence framework.
Additionally, the Hibernate POJO Generator will also create all the necessary test units and helper classesfor each component.
Typically, invocation of the generator generates source code with no errors/warnings and test cases that are able to run immediately without further customizations.
NOTE: Hibernate POJO Generator is distributed and licensed under the terms of the GNU Library or Lesser General Public License (LGPL).

Main features:
Given a source database, Hibernate POJO Generator (hbnPojoGen) generates:
- Java objects representing each table using annotations for use with Hibernate.
- A JUnit test case per table that uses the objects generated to create, populate, save, retrieve and compare results
- DAO per class
- The appropriate enumeration files
- Spring and hibernate configuration
- DAO layers
- A data factory class per schema to return a pre-populated object with random data (for boundary checking, database population, etc)
Also supports:
- Join tables including those with additional fields in link tables
- Polymorphism/inheritance support
- Composite Keys
- One-To-One, many-to-one, many-to-many, etc
- Multiple schema support (4 modes)
- Natural Keys
- Enumerations (including those entries which cannot be mapped cleanly onto the java world)

System requirements:
- Java 6 or later

Oracle JDeveloper is a powerful software that marks a significant milestone in the progress of application development.

We spent more time than ever in this release listening carefully to what our users need in order to make them more productive. We also embarked on an intensive design and usability review by an external company.

The result of these efforts is a huge leap forward in the speed in which developers can create, assemble, and reuse components to build rich, interactive applications that are highly performant and easy to maintain.


Enhanced use experience

There have been many updates throughout the product to make working with JDeveloper a pleasant experience. These improvements are not restricted to a particular type of development, but have been applied consistently to all areas of the design time.
• Enhanced navigator: The Application Navigator has been enhanced to organize your application the way you want. New categories make it easier for you to find what you are looking for. Collapsible panels put common elements of your application within easy reach. Files that make up a composite node are conveniently exposed by simply clicking on the composite node.
• Improved Component Palette: The component palette now features collapsible panels and divider sections to organize related components. A quick search field is provided to help locate components. You can now add commonly-used components to your Favorites list for easier access later, and another panel keeps track of your recently used components.
• New Property Inspector: The Property Inspector has been redesigned with a new, user-friendly layout. Property categories have been used consistently throughout the product to make using the Property Inspector more predictable.
• Application Overview: The new Application Overview window provides a convenient listing of all the sources for your application, grouped into helpful categories. From here, you can get a sense of the overall status of your application (which sources are incomplete, which have errors, etc) too. The Application Overview also functions as a way for you to learn about the various kinds of components you may use in your application, and easily launch wizards to create them.
• File List: The File List makes it easier than ever to locate source files that are part of your project. You can search by file name, file extension, status, date modified and more.
• Updated appearance: The JDeveloper development environment has been updated with a brand-new look.
• Integrated modeless editors: Many editors for components have been converted to integrated modeless editors. These appear in the editor area along with the other editors, and allow for much more productive navigation.
• Contextual linking: Contextual linking is the concept that as you are working on something, you should be able to easily get to relevant related resources. For example, as you are working on defining a page flow for databound pages, you should be able to easily get to the page definition of those pages. This concept is now employed wherever it makes sense in the development environment.


Resource Catalog

The Resource Catalog is your window onto the many disparate resources your application may need to consume. It allows you to define connections to the resource providers, and drag-and-drop those resources into your application as needed. The resource catalog provides a search tool to search all the defined repositories in a single action.

Connections can be created for the following types of resource repositories:
• Application server
• Database
• File system
• UDDI Registry
• URL adapter
• WebDAV

New diagramming framework

The internal diagramming framework used to build the UML tools in JDeveloper, the Page Flow diagrams, and other visual editors has been re-architected to be more flexible for internal consumers.


Java Coding and Agile Development


New code generators

New generators have been added for generating equals and hashcode and to simplify generating fields and properties with getters and setters and to generate constructor from fields

Updated JUnit 4.0 support

JDeveloper now generates unit tests using JUnit 4 annotations. The integrated runner has been updated to support JUnit 4, including new instructions, such as @ignore.

New profilers

The new profilers leverage JVMTI and therefore run on any certified Java VM. Oracles OJVM is no longer required for profiling.
• CPU Profiler
• Memory Profiler

XML Compare

Comparing of XML files is now done using an XML-aware algorithm. In previous releases compare was done using a line algorithm with no understanding of the syntax of the file content. XML is used extensively within JDeveloper (projects, diagrams, ADF artifacts) and the characteristics of the file content will be understood by the tool.

For example if an XML elements attributes are reordered the compare tool will not mark that as a change - the attributes (name and value) are the same, but in different positions.

The compare tool is used by all the version control extensions to compare file content with previous versions. Compare is also used by the local history feature to compare content between saved points.

Enhanced Merge Conflict Resolution for Subversion and CVS

JDeveloper now provides an enhanced XML-aware interactive GUI to browse and update unresolvable conflicts reported during the merge process.