Assignment 3: Getting Started with Java, Testing, and Objects

Consider the six following static methods.

We will group all of these in a class we call PartA. (How's that for creative naming?)

0. Write a class, PartA which contains stub versions of each method. A stub method is a really simple implementation that may not do what is advertised, but returns a value so that we can still compile the code and use it during development. For example, you might start with the follwoing.

public class PartA
{
  /**
   * Determine if a is a multiple of b.
   */
  public static boolean isMultiple(long a, long b)
  {
    // STUB
    return true;
  } // isMultiple(long, long)
} // class PartA

1. Write a class, TestPartA, which contains six methods, each of which tests one of the methods above. When creating this class in Eclipse, use New > JUnit Test Case Your tests should use the assertEquals(String message, type expected, type actual) method. For example, you might start with the following.

public class TestPartA
{
  @Test
  void test_isOdd(void) 
    throws Exception
  {
    assertEquals("negative even", false, PartA.isOdd(-4));
    // Integer.MAX_VALUE is 2^31 - 1, which is odd
    assertEquals("MAX_VALUE", true, PartA.isOdd(Integer.MAX_VALUE));
    ...
  } // test_isOdd

  @Test
  void test_reverseInts(void)
    throws Exception
  {
    assertArrayEquals(new int[] {}, 
                      PartA.reverseInts(new int[] {}));
    assertArrayEquals(new int[] { 1 }, 
                      PartA.reverseInts(new int[] { 1 }));
    assertArrayEquals(new int[] { 1, 2 }, 
                      PartA.reverseInts(new int[] { 2, 1 }));
    ...
  } // test_reverseInts
} // class TestPartA

2. Implement all of the methods in PartA.

The following method has at least one subtle bug. Identify and correct that bug.

public class PartB {
  /**
   * Compute the average of two integers.  Rounds toward zero if the
   * average is not a whole number.
   */
  public static int average(int left, int right) 
  {
    return ((left + right) / 2);
  } // average(int,int)
} // class PartB

Hint: The algorithm works correctly for most pairs numbers. It only fails to compute the correct value for certain pairs of numbers. So think about what some special cases might be.

When designing objects, a good first step is to consider what natural operations are associated with the object. Traditionally, we consider three kinds of operations:

Some methods do more than one thing. For example, an object that represents an idea might have a method that creates a derivative idea. Such a method is a constructor, because it creates a new idea. But it's also likely to mutate our original idea (at the very least, by creating a link to the derivative).

Your goal in this problem is to reflect on the objects we might use in programming Ushahidi in Java.

First visit the class Ushahidi site at http://ushahidi1.grinnell.edu/sandbox. Explore a bit to understand the basic capabilities of Ushahidi. Submit a report on the site. Since it's a site for our use, you can do what you want for the submission. However, please be polite in what you write.

Suppose we want to represent the primary information for Ushahidi (at least the incidents). Sketch the classes you would use and the fields and methods you would include in each class. You may choose to write Java code with stub methods or you can put everything in a big comment.

Here's a sample stub method.

  /**
   * Get the name of the owner of this resource.
   */
  public String getOwnerName()
  {
    return "Casey Smith";
  } // getOwnerName()

When you need to return an object in a stub method, the easiest thing is to return the value null. (Okay, that may make other code break; but right now we're just trying to describe goals.)

  /**
   * Get the owner of this resource.
   */
  public UshahidiUser getOwner()
  {
    return null;
  } // getOwner()

Here's a comment that provides the same information as these two stub methods. The advantage of the comment is that we don't have to worry about getting the Java right for the compiler.

/*
   Method:      getOwnerName
   Type:        Observer
   Purpose:     Get the name of the owner of this resource.
   Parameters:  [none]
   Produces:    name, a String

   Method:      getOwner
   Type:        Observer
   Purpose:     Get the owner of this resource
   Parameters:  [none]
   Produces:    owner, an UshahidiUser
 */

Note that the object is implicit for methods associated with that object. Hence, you need not specify the object you are working with.

You may be familiar with a classic algorithm by Shirley Ellis entitled The Name Game. Ms. Ellis describes this algorithms for developing phrases based on her colleague's names as follows:

She also gives us a number of examples:

Write a method, nameGame, that takes as input a string and returns a string that contains a verse of the form Ms. Ellis suggests. Your method need not function correctly with names that begin with vowels, although you must handle situations in which the name begins with multiple consonants (as in the case of “Shirley”).

You need not write test cases for this procedure! A few simple experiments should suffice.