NKDA offers green tokens to successful planters

first_imgKolkata: New Town Kolkata Development Authority (NKDA) will give green tokens to those who have successfully maintained the saplings that were given to them in 2017 as part of its massive afforestation drive jointly with the state Forest department.Those who can obtain two out of the three green tokens will be given T-shirt and other gifts to encourage them to grow plants with care. Five young mothers and their daughters were given saplings under the Sabujshree project at a function held near the Clock Tower in New Town on Saturday afternoon. The unique project is an initiative of Chief Minister Mamata Banerjee where young mothers and their daughters are given saplings. The family is supposed to grow the tree and when the girl child attains the age of 18 years, the family can sell the tree to help her study further. The NKDA will distribute a pack of 25 saplings among schools, colleges and other institutions in New Town as part of the drive. It has also taken steps for avenue plantation. All those who attended the function were given two saplings. Also Read – Speeding Jaguar crashes into Merc, 2 B’deshi bystanders killedThe NKDA will set up an urban pocket garden near the Clock Tower and senior officials will plant saplings for the same.New Town is coming up as a green city and various measures have already been taken in this regard. There is waste water recycling and the recycled water is being used to water the roadside plants. LED lamps have been installed to bring down pollution levels.Bicycles have been introduced as part of the cycle sharing scheme. Electric air-conditioned buses have been introduced and e-cars will soon be launched. Eco Park has also been developed as the biggest urban park in eastern India.last_img read more

Unit testing with Java frameworks JUnit and TestNG Tutorial

center_img Frequent manual testing is too impractical for any but the smallest systems. The only way around this is the use of automated tests. Automated tests are an effective method to reduce the time and cost of building, deploying, and maintaining applications. In order to effectively manage applications, it is of the utmost importance that both the implementation and test codes are as simple as possible. In this tutorial, we will look at implementing simple and easy to learn Java Unit testing frameworks for writing and running test i.e. JUnit and TestNG. You are reading Java unit testing tutorial from the book Test Driven Java Development – Second Edition, written by Alex Garcia and Viktor Farcic. Simplicity of code is one of the core extreme programming (XP) values and the key to Test Driven Development (TDD) and programming in general. It is most often accomplished through division into small units. In Java, units are methods. Being the smallest, the feedback loop they provide is the fastest so we spend most of our time thinking about and working on them. As a counterpart to implementation methods, unit tests should constitute by far the biggest percentage of all tests. So let us look at what is Unit testing and then get into the usage of the frameworks. What is Unit testing? Unit testing is a practice that forces us to test small, individual, and isolated units of code. They are usually methods, even though in some cases classes or even whole applications can be considered to be units, as well. In order to write unit tests, code under tests needs to be isolated from the rest of the application. Preferably, that isolation is already ingrained in the code or it can be accomplished with the use of mocks. If unit tests of a particular method cross the boundaries of that unit, then they become integration tests. As such, it becomes less clear what is under the tests. In case of a failure, the scope of a problem suddenly increases and finding the cause becomes more tedious. Java Unit testing frameworks In this section, two of the most used Java frameworks for unit testing are shown and briefly commented on. We will focus on their syntax and main features by comparing a test class written using both JUnit and TestNG. Although there are slight differences, both frameworks offer the most commonly used functionalities, and the main difference is how tests are executed and organized. Let’s start with a question. What is a test? How can we define it? A test is a repeatable process or method that verifies the correct behavior of a tested target in a determined situation with a determined input expecting a predefined output or interactions. In the programming approach, there are several types of tests depending on their scope—functional tests, acceptance tests, and unit tests. Further on, we will explore each of those types of tests in more detail. Let’s see how to test a single Java class. The class is quite simple, but enough for our interest: public class Friendships { private final Map> friendships = new HashMap(); private void addFriend(String person, String friend) { if (!friendships.containsKey(person)) { friendships.put(person, new ArrayList()); } List friends = friendships.get(person); if (!friends.contains(friend)) { friends.add(friend); } } } Testing with JUnit JUnit is a simple and easy-to-learn framework for writing and running tests. Each test is mapped as a method, and each method should represent a specific known scenario in which a part of our code will be executed. The code verification is made by comparing the expected output or behavior with the actual output. The following is the test class written with JUnit. There are some scenarios missing, but for now we are interested in showing what tests look like. We will focus on better ways to test our code and on best practices later in this book. Test classes usually consist of three stages: set up, test, and tear down. Let’s start with methods that set up data needed for tests. A setup can be performed on a class or method level: Friendships friendships; @After public void after() { // This method will be executed once after each test execution } In our example, in the Friendships class, we have no need to clean up anything. If there were such a need, those two annotations would provide that feature. They work in a similar fashion to the @Before and @BeforeClass annotations. @AfterClass is run once all tests are finished. The @After annotation is executed after each test. This runs each test method as a separate class instance. As long as we are avoiding global variables and external resources, such as databases and APIs, each test is isolated from the others. Whatever was done in one, does not affect the rest. The complete source code can be found in the FriendshipsTest class at https://bitbucket.org/vfarcic/tdd-java-ch02-example-junit. Testing with TestNG In TestNG, tests are organized in classes, just as in the case of JUnit. The following Gradle configuration (build.gradle) is required in order to run TestNG tests: dependencies { testCompile group: ‘org.testng’, name: ‘testng’, version: ‘6.8.21’ } @BeforeClass public static void beforeClass() { // This method will be executed once on initialization time } @Before public void before() { friendships = new Friendships(); friendships.makeFriends(“Joe”,”,,” “Audrey”); friendships.makeFriends(“Joe”, “Peter”); friendships.makeFriends(“Joe”, “Michael”); friendships.makeFriends(“Joe”, “Britney”); friendships.makeFriends(“Joe”, “Paul”); } The @BeforeClass annotation specifies a method that will be run once before any of the test methods in the class. It is a useful way to do some general set up that will be used by most (if not all) tests. The @Before annotation specifies a method that will be run before each test method. We can use it to set up test data without worrying that the tests that are run afterwards will change the state of that data. In the preceding example, we’re instantiating the Friendships class and adding five sample entries to the Friendships list. No matter what changes will be performed by each individual test, this data will be recreated over and over until all the tests are performed. Common examples of usage of those two annotations are the setting up of database data, the creation of files needed for tests, and so on. Later on, we’ll see how external dependencies can and should be avoided using mocks. Nevertheless, functional or integration tests might still need those dependencies and the @Before and @BeforeClass annotations are a good way to set them up. Once the data is set up, we can proceed with the actual tests: @Test public void alexDoesNotHaveFriends() { Assert.assertTrue(“Alex does not have friends”, friendships.getFriendsList(“Alex”).isEmpty()); } last_img read more