Java Classes Implementation in Java Assignment Solution

June 29, 2024

Alex Thompson

🇺🇸 United States

Java

Alex Thompson is a skilled Java Assignment Expert with 8 years of experience. He completed his Master's degree at Stanford University, USA.

Hire Now

Java

Key Topics

Instructions
Requirements and Specifications

Submit Your Java Assignment

Get a FREE Quote

Tip of the day

Use Python libraries effectively by importing only what you need. For example, if you're working with data, using libraries like pandas and numpy can save time and simplify complex tasks like data manipulation and analysis.

News

In 2024, the Biden-Harris Administration has expanded high-dosage tutoring and extended learning programs to boost academic achievement, helping programming students and others recover from pandemic-related setbacks. These initiatives are funded by federal resources aimed at improving math and literacy skills

Instructions

Objective

Write a java assignment program to implement java classes.

Requirements and Specifications

Source Code

TEST EFFICIENCY
import java.util.Random;
import edu.uwm.cs351.SortedSequence;
import junit.framework.TestCase;
public class TestEfficiency extends TestCase {
 private SortedSequencess;
 private static final int POWER = 21; // 1 million entries
 private static final int TESTS = 100_000;
 protected void setUp() throws Exception {
  super.setUp();
  new Random();
  try {
   assert ss.size() == TESTS : "cannot run test with assertions enabled";
  } catch (NullPointerException ex) {
   System.err.println("You need to turn off assertions.");
   System.err.println("Go to Run Configurations > TestEfficiency and go to the Arguments tab");
   System.err.println("and remove -ea from the VM Arguments box.");
   throw new IllegalStateException("Cannot run test with assertions enabled");
  }
  ss = new SortedSequence<>((i1,i2) -> i1 - i2);
  int max = (1 << (POWER)); // 2^(POWER) = 2 million
  for (int power = POWER; power > 1; --power) {
   int incr = 1 << power;
   for (int i=1 << (power-1); i < max; i += incr) {
    ss.add(i);
   }
  }
 }
 @Override
 protected void tearDown() throws Exception {
  ss = null;
  super.tearDown();
 }
 public void testSize() {
  for (int i=0; i < TESTS; ++i) {
   assertEquals((1<<(POWER-1))-1,ss.size());
  }
 }
 public void testGet() {
  ss.start();
  int max = 1 << POWER;
  for (int i=2; i < max; i += 2) {
   Integer elem = ss.getCurrent();
   assertEquals(i/10, elem/10);
   ss.advance();
  }
 }
 public void testRemove() {
  int max = (1 << (POWER)); // 2^(POWER) = 2 million
  int power = 4;
  int incr = 1 << power;
  ss.start();
  for (int i=1 << (power-1); i < max; i += incr) {
   while (ss.getCurrent().intValue() != i) {
    assertTrue(ss.getCurrent()/10 <= i/10);
    ss.advance();
   }
   ss.removeCurrent();
  }
  int removed = 1<<(POWER-power);
  assertEquals(max/2 - 1 - removed, ss.size());
 }
 public void testClone() {
  int pow = POWER/2;
  int num = 1 << pow;
  while (pow > 1) {
   --pow;
   num += (1 << pow);
   --pow;
   num -= (1 << pow);
  }
  System.out.println("num = " + num);
  ss.add(num-1);
  ss.removeCurrent();
  assertEquals(num+1, ss.getCurrent().intValue());
  SortedSequencec = ss.clone();
  assertEquals(num+1, c.getCurrent().intValue());
  c.removeCurrent();
  assertEquals(num+1, ss.getCurrent().intValue());
  assertEquals(num+3, c.getCurrent().intValue());
  ss.advance();
  assertEquals(num+3, ss.getCurrent().intValue());
  assertEquals(num+3, c.getCurrent().intValue());
  ss.advance();
  assertEquals(num+5, ss.getCurrent().intValue());
  assertEquals(num+3, c.getCurrent().intValue());
  ss.advance();
  assertEquals(num+7, ss.getCurrent().intValue());
  assertEquals(num+3, c.getCurrent().intValue());
 }
}
TEST INTERNALS
import edu.uwm.cs351.SortedSequence;
public class TestInternals extends SortedSequence.TestInternals {
 /// Locked tests:
 @SuppressWarnings("unused")
 public void test() {
  // Which single-character strings can fit in the given
  // spots in this tree? (Using case-insensitive ordering)
  // C
  // / \
  // A e
  // \ /
  // # $
  // Write your answer as a sorted set without spaces
  // in which UPPERCASE letters precede lowercase letters.
  // For example: {K,k,L}, not {k,K,L} or {K, k, L } or {K,L,k}
  String answer1 = Ts(2034396360); // what keys at #
  String answer2 = Ts(577043295); // what keys at $
  testCont(false);
 }
 @SuppressWarnings("unused")
 private void testCont(boolean ignored) {
  // We are checking the "immediate greater ancestor" property
  // for nodes in this tree:
  // M
  // / \
  // / \
  // G S
  // / \ / \
  // D K P W
  // / \ \ \ \
  // A F L Q Y
  // Give the letter or "none"
  String answer1 = Ts(960628806); // imm. gr. ancestor of A ?
  String answer2 = Ts(1533686037); // imm. gr. ancestor of K ?
  String answer3 = Ts(1529894885); // imm. gr. ancestor of Q ?
  String answer4 = Ts(1790270167); // imm. gr. ancestor of Y ?
  testCont2(false);
 }
 @SuppressWarnings("unused")
 private void testCont2(boolean ignored) {
  // What are the valid cursor stacks for this tree?
  // M
  // / \
  // / \
  // G S
  // / \ / \
  // D K P W
  // / \ \ \ \
  // A F L Q Y
  // Write the stack with square brackets, commas, with the top to the right
  // but without spaces: e.g. [M,G,F] (when "F" is current)
  String answer1 = Ts(1039507205); // the stack after we call start() ("A" is current").
  String answer2 = Ts(1892415530); // The stack after we next call advance() ("D" is current").
  String answer3 = Ts(1308770658); // The stack when "L" is current
  String answer4 = Ts(395215552); // The stack when "Q" is current
 }
}
TEST SORTED SEQUENCE
import edu.uwm.cs.junit.LockedTestCase;
import edu.uwm.cs351.SortedSequence;
public class TestSortedSequence extends LockedTestCase {
 Integer b1 = 100;
 Integer b2 = 50;
 Integer b3 = 33;
 Integer b4 = 25;
 Integer b5 = 20;
 SortedSequences, se;
 SortedSequencess;
 @Override
 protected void setUp() {
  s = new SortedSequence((i1,i2) -> i2 - i1);
  se = new SortedSequence((i1,i2) -> i1 - i2);
  ss = new SortedSequence(String.CASE_INSENSITIVE_ORDER);
  try {
   assert 1/(b1-100) == 42 : "OK";
   System.err.println("Assertions must be enabled to use this test suite.");
   System.err.println("In Eclipse: add -ea in the VM Arguments box under Run>Run Configurations>Arguments");
   assertFalse("Assertions must be -ea enabled in the Run Configuration>Arguments>VM Arguments",true);
  } catch (ArithmeticException ex) {
   return;
  }
 }
 protected void assertException(ClassexcClass, Runnable f) {
  try {
   f.run();
   assertFalse("Should have thrown an exception, not returned ",true);
  } catch (RuntimeException ex) {
   if (!excClass.isInstance(ex)) {
    assertFalse("Wrong kind of exception thrown: "+ ex.getClass().getSimpleName(),true);
   }
  }
 }
 //// Locked Tests
 public void test() {
  // "ss" is sorted case insensitive (so "a" and "A" are sorted together, before "b" and "B").
  ss.add("Foo");
  ss.add("FOO");
  ss.add("foo");
  ss.add("fu");
  ss.add("bar");
  ss.start();
  assertEquals(Ts(540777888), ss.getCurrent());
  ss.advance();
  assertEquals(Ts(841015913), ss.getCurrent());
  ss.add("BAR");
  assertEquals(Ts(689167294), ss.getCurrent());
  ss.advance();
  assertEquals(Ts(1452336162), ss.getCurrent());
  testCont(false);
 }
 private void testCont(boolean ignored) {
  // ss is sorted case-insensitive
  // ss = [bar, BAR, *Foo, FOO, foo, fu] ("Foo" is current)
  ss.removeCurrent();
  assertEquals(Ti(917957413), ss.size());
  assertEquals(Ts(359804329), ss.getCurrent());
  ss.add("Foo");
  assertEquals(Ts(817754356), ss.getCurrent());
  ss.advance();
  assertEquals(Ts(815169093), ss.getCurrent());
 }
 //// Numbered tests
 /// test0N: simple tests on the empty sequence
 public void test00() {
  assertEquals(0,s.size());
 }
 public void test01() {
  assertFalse(s.isCurrent());
 }
 public void test02() {
  s.start(); // doesn't crash
 }
 public void test03() {
  assertException(IllegalStateException.class,() -> s.getCurrent());
 }
 public void test04() {
  assertException(IllegalStateException.class, () -> s.advance());
 }
 public void test05() {
  s.start();
  assertFalse(s.isCurrent());
 }
 public void test06() {
  assertEquals(0,s.size());
 }
 /// test1N: tests of a single element sequence
 public void test10() {
  s.add(b1);
  assertEquals(1,s.size());
 }
 public void test11() {
  s.add(b2);
  assertTrue(s.isCurrent());
 }
 public void test12() {
  s.add(b3);
  assertSame(b3,s.getCurrent());
 }
 public void test13() {
  s.add(b4);
  s.start();
  assertSame(b4,s.getCurrent());
 }
 public void test14() {
  s.add(b5);
  s.advance();
  assertFalse(s.isCurrent());
 }
 public void test15() {
  s.add(b5);
  s.advance();
  s.start();
  assertTrue(s.isCurrent());
 }
 public void test16() {
  assertException(NullPointerException.class, ()-> s.add(null));
  assertEquals(0,s.size());
 }
 public void test19() {
  s.add(b1);
  assertEquals(1,s.size());
  assertTrue(s.isCurrent());
  assertSame(b1,s.getCurrent());
 }
 /// test2N: tests of two element sequences
 public void test20() {
  s.add(b1);
  s.add(b2);
  assertEquals(2,s.size());
 }
 public void test21() {
  s.add(b3);
  s.add(b4);
  assertTrue(s.isCurrent());
 }
 public void test22() {
  s.add(b1);
  s.add(b2);
  assertSame(b2,s.getCurrent());
 }
 public void test23() {
  s.add(b1);
  s.add(b2);
  s.advance();
  assertFalse(s.isCurrent());
 }
 public void test24() {
  s.add(b4);
  s.add(b5);
  s.start();
  assertTrue(s.isCurrent());
  assertEquals(2,s.size());
  assertEquals(b4,s.getCurrent());
 }
 public void test25() {
  s.add(b2);
  s.add(b5);
  s.start();
  s.advance();
  s.start();
  assertTrue(s.isCurrent());
  assertEquals(2,s.size());
  assertEquals(b2,s.getCurrent());
 }
 public void test26() {
  s.add(b1);
  s.advance();
  s.add(b2);
  assertTrue(s.isCurrent());
  assertSame(b2,s.getCurrent());
 }
 public void test27() {
  s.add(b3);
  s.advance();
  s.add(b4);
  assertEquals(2,s.size());
  assertTrue(s.isCurrent());
  assertSame(b4,s.getCurrent());
 }
 public void test28() {
  s.add(b1);
  assertException(NullPointerException.class, () -> s.add(null));
  assertEquals(1,s.size());
 }
 /// test3N: tests of three or more element sequences
 public void test30() {
  s.add(b1);
  s.add(b2);
  s.add(b3);
  assertEquals(3,s.size());
  assertSame(b3,s.getCurrent());
  s.advance();
  assertFalse(s.isCurrent());
  s.start();
  assertSame(b1,s.getCurrent());
  s.advance();
  assertSame(b2,s.getCurrent());
  s.advance();
  assertSame(b3,s.getCurrent());
 }
 public void test31() {
  s.add(b4);
  s.add(b5);
  s.advance();
  s.add(b1);
  assertSame(b1,s.getCurrent());
  s.advance();
  assertEquals(3,s.size());
  assertSame(b4,s.getCurrent());
  s.advance();
  assertSame(b5,s.getCurrent());
  s.advance();
  assertFalse(s.isCurrent());
 }
 public void test32() {
  s.add(b2);
  s.add(b4);
  s.start();
  s.add(b3);
  assertSame(b3,s.getCurrent());
  s.advance();
  assertSame(b4,s.getCurrent());
  s.advance();
  assertFalse(s.isCurrent());
  s.start();
  assertSame(b2,s.getCurrent());
  assertEquals(3,s.size());
 }
 public void test33() {
  s.add(b1);
  assertException(NullPointerException.class, () -> s.add(null));
  s.add(b2);
  assertSame(b2,s.getCurrent());
  s.start();
  assertSame(b1,s.getCurrent());
  s.advance();
  assertTrue(s.isCurrent());
  assertSame(b2,s.getCurrent());
 }
 public void test34() {
  s.add(b4);
  s.add(b5);
  s.advance();
  s.add(b3);
  assertSame(b3, s.getCurrent());
  assertEquals(3,s.size());
  s.advance();
  assertSame(b4,s.getCurrent());
 }
 public void test35() {
  s.add(b1);
  s.add(b2);
  s.add(b3);
  s.start();
  s.add(b4);
  assertSame(b4,s.getCurrent());
  s.advance();
  assertException(IllegalStateException.class,() -> s.getCurrent() );
  s.start();
  assertSame(b1,s.getCurrent());
  s.advance();
  assertSame(b2,s.getCurrent());
  s.advance();
  assertSame(b3,s.getCurrent());
 }
 public void test36() {
  s.add(b5);
  s.add(b4);
  s.add(b3);
  s.start();
  s.advance();
  s.add(b2);
  assertEquals(b2,s.getCurrent());
  assertEquals(4,s.size());
  s.advance();
 }
 public void test37() {
  s.add(b1);
  s.advance();
  s.add(b2);
  s.advance();
  s.add(b3);
  s.advance();
  s.add(b4);
  s.advance();
  s.add(b5);
  s.start();
  assertSame(b1,s.getCurrent());
  s.advance();
  s.advance();
  assertSame(b3,s.getCurrent());
  s.advance();
  s.advance();
  s.advance();
  assertFalse(s.isCurrent());
  assertException(IllegalStateException.class,() -> s.advance() );
 }
 public void test38() {
  s.add(b1);
  s.add(b2);
  s.add(b3);
  s.add(b4);
  s.add(b5);
  s.add(b5);
  s.add(b4);
  s.add(b3);
  s.add(b2);
  s.add(b1);
  s.add(b1);
  s.add(b2);
  s.add(b3);
  s.add(b4);
  s.add(b5);
  assertEquals(15,s.size());
  s.start();
  assertSame(b1,s.getCurrent()); s.advance();
  assertSame(b1,s.getCurrent()); s.advance();
  assertSame(b1,s.getCurrent()); s.advance();
  assertSame(b2,s.getCurrent()); s.advance();
  assertSame(b2,s.getCurrent()); s.advance();
  assertSame(b2,s.getCurrent()); s.advance();
  assertSame(b3,s.getCurrent()); s.advance();
  assertSame(b3,s.getCurrent()); s.advance();
  assertSame(b3,s.getCurrent()); s.advance();
  assertSame(b4,s.getCurrent()); s.advance();
  assertSame(b4,s.getCurrent()); s.advance();
  assertSame(b4,s.getCurrent()); s.advance();
  assertSame(b5,s.getCurrent()); s.advance();
  assertSame(b5,s.getCurrent()); s.advance();
  assertSame(b5,s.getCurrent()); s.advance();
  assertFalse(s.isCurrent());
 }
 public void test39() {
  for (int i=0; i < 39; ++i) {
   s.add(i);
  }
  assertEquals(39,s.size());
  s.start();
  for (int i=0; i < 39; ++i) {
   assertTrue(s.isCurrent());
   assertEquals(38-i,s.getCurrent().intValue());
   s.advance();
  }
  assertFalse(s.isCurrent());
 }
 /// test4N: tests of removeCurrent
 public void test40() {
  s.add(b1);
  s.removeCurrent();
  assertFalse(s.isCurrent());
 }
 public void test41() {
  s.add(b2);
  s.removeCurrent();
  assertEquals(0,s.size());
 }
 public void test42() {
  s.add(b3);
  s.add(b4);
  s.removeCurrent();
  assertFalse(s.isCurrent());
  assertEquals(1,s.size());
  s.start();
  assertSame(b3,s.getCurrent());
 }
 public void test43() {
  s.add(b4);
  s.add(b3);
  s.start();
  s.removeCurrent();
  assertTrue(s.isCurrent());
  assertSame(b4,s.getCurrent());
 }
 public void test44() {
  s.add(b4);
  s.add(b5);
  s.start();
  s.removeCurrent();
  assertTrue(s.isCurrent());
  assertSame(b5,s.getCurrent());
 }
 public void test45() {
  s.add(b4);
  s.add(b3);
  s.add(b5);
  s.start();
  s.advance();
  s.removeCurrent();
  assertSame(b5,s.getCurrent());
  s.advance();
  assertFalse(s.isCurrent());
  assertEquals(2,s.size());
  s.start();
  assertSame(b3,s.getCurrent());
 }
 public void test46() {
  s.add(b4);
  s.add(b5);
  s.add(b1);
  s.removeCurrent();
  assertEquals(2,s.size());
  assertSame(b4,s.getCurrent()); s.advance();
  assertSame(b5,s.getCurrent()); s.advance();
  assertFalse(s.isCurrent());
 }
 public void test47() {
  s.add(b1);
  s.add(b2);
  s.add(b3);
  s.add(b4);
  s.add(b5);
  s.start();
  assertSame(b1,s.getCurrent()); s.advance();
  assertSame(b2,s.getCurrent());
  s.removeCurrent();
  assertSame(b3,s.getCurrent()); s.advance();
  assertSame(b4,s.getCurrent());
  s.removeCurrent();
  assertSame(b5,s.getCurrent()); s.advance();
  assertFalse(s.isCurrent());
  s.start();
  assertSame(b1,s.getCurrent()); s.advance();
  assertSame(b3,s.getCurrent()); s.advance();
  assertSame(b5,s.getCurrent()); s.advance();
  assertFalse(s.isCurrent());
 }
 public void test48() {
  s.add(b1);
  s.add(b2);
  s.add(b3);
  s.add(b4);
  s.add(b5);
  s.start();
  assertSame(b1,s.getCurrent()); s.removeCurrent();
  assertSame(b2,s.getCurrent()); s.advance();
  assertSame(b3,s.getCurrent()); s.removeCurrent();
  assertSame(b4,s.getCurrent()); s.advance();
  assertSame(b5,s.getCurrent()); s.removeCurrent();
  assertFalse(s.isCurrent());
  s.start();
  assertSame(b2,s.getCurrent()); s.advance();
  assertSame(b4,s.getCurrent()); s.advance();
  assertFalse(s.isCurrent());
 }
 public void test49() {
  for (int i=0; i < 49; ++i) {
   s.add(i);
  }
  s.start();
  for (int i=0; i < 49; ++i) {
   assertEquals(48-i,s.getCurrent().intValue());
   if ((i%2) == 0) s.removeCurrent();
   else s.advance();
  }
  s.start();
  for (int i=0; i < 24; ++i) {
   assertEquals(47-i*2,s.getCurrent().intValue());
   s.removeCurrent();
  }
  assertEquals(0,s.size());
 }
 /// test5N: errors with removeCurrent
 public void test50() {
  assertException(IllegalStateException.class, () -> s.removeCurrent());
 }
 public void test51() {
  s.add(b1);
  s.advance();
  assertException(IllegalStateException.class, () -> s.removeCurrent());
 }
 public void test52() {
  s.add(b1);
  s.removeCurrent();
  assertException(IllegalStateException.class, () -> s.removeCurrent());
 }
 public void test53() {
  s.add(b1);
  s.add(b2);
  s.removeCurrent();
  assertException(IllegalStateException.class, () -> s.removeCurrent());
 }
 public void test54() {
  s.add(b1);
  s.add(b2);
  s.add(b3);
  s.add(b4);
  s.add(b5);
  s.advance();
  assertException(IllegalStateException.class, () -> s.removeCurrent());
 }
 public void test55() {
  s.add(b5);
  s.advance();
  assertException(IllegalStateException.class, () -> s.removeCurrent());
  s.add(b4);
  s.advance();
  s.advance();
  assertException(IllegalStateException.class, () -> s.removeCurrent());
  s.add(b3);
  s.advance();
  s.advance();
  s.advance();
  assertException(IllegalStateException.class, () -> s.removeCurrent());
  s.add(b2);
  s.advance();
  s.advance();
  s.advance();
  s.advance();
  assertException(IllegalStateException.class, () -> s.removeCurrent());
  s.add(b1);
  assertEquals(5,s.size());
  assertSame(b1,s.getCurrent()); s.advance();
  assertSame(b2,s.getCurrent()); s.advance();
  assertSame(b3,s.getCurrent()); s.advance();
  assertSame(b4,s.getCurrent()); s.advance();
  assertSame(b5,s.getCurrent()); s.advance();
  assertFalse(s.isCurrent());
 }
 /// test6X: tests with distinguished equivalent elements
 public void test60() {
  ss.add("six");
  ss.add("Six");
  ss.add("Sixty");
  ss.add("SIX");
  assertEquals("SIX", ss.getCurrent());
  ss.advance();
  assertEquals("Sixty", ss.getCurrent());
  ss.advance();
  assertException(IllegalStateException.class, () -> ss.getCurrent());
 }
 public void test61() {
  ss.add("six");
  ss.add("SIX");
  ss.add("six");
  ss.start();
  assertEquals("six", ss.getCurrent());
  ss.advance();
  assertEquals("SIX", ss.getCurrent());
  ss.advance();
  assertEquals("six", ss.getCurrent());
 }
 /// test7X: tests of remove of equivalent elements
 public void test70() {
  ss.add("seven");
  ss.add("Seven");
  ss.removeCurrent();
  assertEquals(1, ss.size());
  assertFalse(ss.isCurrent());
  ss.start();
  assertEquals("seven", ss.getCurrent());
  ss.advance();
  assertFalse(ss.isCurrent());
 }
 public void test71() {
  ss.add("Seven");
  ss.add("seven");
  ss.start();
  ss.removeCurrent();
  assertEquals(1, ss.size());
  assertEquals("seven", ss.getCurrent());
 }
 public void test72() {
  ss.add("seven");
  ss.add("seventy");
  ss.add("SEVEN");
  ss.removeCurrent();
  assertEquals(2, ss.size());
  assertEquals("seventy", ss.getCurrent());
  ss.start();
  assertEquals("seven", ss.getCurrent());
  ss.advance();
  assertEquals("seventy", ss.getCurrent());
 }
 public void test73() {
  ss.add("seven");
  ss.add("seventy");
  ss.add("Seventy");
  ss.add("Seven");
  ss.start();
  ss.advance();
  ss.advance();
  assertEquals("seventy", ss.getCurrent());
  ss.removeCurrent();
  assertEquals("Seventy", ss.getCurrent());
 }
 public void test74() {
  ss.add("seven");
  ss.add("seventy");
  ss.add("Seventy-seven");
  ss.add("Seven");
  ss.add("sevens");
  ss.add("SEVEN");
  ss.add("Seventy");
  ss.start();
  ss.advance();
  ss.advance();
  ss.advance();
  ss.advance();
  assertEquals("seventy", ss.getCurrent());
  ss.removeCurrent();
  assertEquals("Seventy", ss.getCurrent());
 }
 public void test75() {
  ss.add("seven");
  ss.add("five");
  ss.add("Five");
  ss.add("FIVE");
  ss.add("eight");
  ss.add("seventy");
  ss.add("SEVEN");
  ss.add("seventy-five");
  ss.start();
  ss.advance();
  ss.advance();
  ss.advance();
  ss.advance();
  assertEquals("seven", ss.getCurrent());
  ss.removeCurrent();
  assertEquals("SEVEN", ss.getCurrent());
  ss.advance();
  assertEquals("seventy", ss.getCurrent());
  ss.advance();
  assertEquals("seventy-five", ss.getCurrent());
 }
 public void test77() {
  ss.add("seven");
  ss.add("Seven");
  ss.add("seventy");
  ss.add("seven");
  ss.removeCurrent();
  assertEquals("seventy", ss.getCurrent());
  ss.start();
  assertEquals("seven", ss.getCurrent());
  ss.advance();
  assertEquals("Seven", ss.getCurrent());
  ss.advance();
  assertEquals("seventy", ss.getCurrent());
 }
 /// test9N: testing clone
 public void test90() {
  SortedSequencec = s.clone();
  assertFalse(c.isCurrent());
  assertEquals(0, c.size());
 }
 public void test91() {
  s.add(b1);
  SortedSequencec = s.clone();
  assertTrue(s.isCurrent());
  assertSame(b1,s.getCurrent()); s.advance();
  assertFalse(s.isCurrent());
  assertTrue(c.isCurrent());
  assertSame(b1,c.getCurrent()); c.advance();
  assertFalse(c.isCurrent());
 }
 public void test92() {
  s.add(b1);
  s.advance();
  SortedSequencec = s.clone();
  assertFalse(s.isCurrent());
  assertFalse(c.isCurrent());
  c.start();
  assertTrue(c.isCurrent());
  assertSame(b1,c.getCurrent());
 }
 public void test93() {
  s.add(b1);
  s.add(b2);
  SortedSequencec = s.clone();
  assertTrue(s.isCurrent());
  assertTrue(c.isCurrent());
  assertSame(b2,s.getCurrent());
  assertSame(b2,c.getCurrent());
  s.advance();
  c.advance();
  assertFalse(s.isCurrent());
  assertFalse(c.isCurrent());
 }
 public void test94() {
  s.add(b2);
  s.add(b1);
  s.add(b3);
  s.start();
  SortedSequencec = s.clone();
  assertSame(b1,s.getCurrent());
  assertSame(b1,c.getCurrent());
  s.advance();
  c.advance();
  assertTrue(s.isCurrent());
  assertTrue(c.isCurrent());
  assertSame(b2,s.getCurrent());
  assertSame(b2,c.getCurrent());
  s.advance();
  c.advance();
  assertTrue(s.isCurrent());
  assertTrue(c.isCurrent());
  assertSame(b3,s.getCurrent());
  assertSame(b3,c.getCurrent());
 }
 public void test95() {
  s.add(b1);
  SortedSequencec = s.clone();
  s.add(b2);
  assertSame(b2,s.getCurrent());
  assertSame(b1,c.getCurrent());
  s.advance();
  assertFalse(s.isCurrent());
  c.advance();
  assertFalse(c.isCurrent());
  assertEquals(1,c.size());
  assertEquals(2,s.size());
 }
 public void test96() {
  s.add(b1);
  s.add(b2);
  SortedSequencec = s.clone();
  s.add(b3);
  assertSame(b3,s.getCurrent());
  assertSame(b2,c.getCurrent());
  c.advance();
  s.advance();
  assertFalse(s.isCurrent());
  assertFalse(c.isCurrent());
  assertEquals(2,c.size());
  assertEquals(3,s.size());
 }
 public void test97() {
  s.add(b1);
  s.add(b2);
  s.add(b3);
  s.start();
  SortedSequencec = s.clone();
  assertSame(b1,s.getCurrent());
  assertSame(b1,c.getCurrent());
  s.removeCurrent();
  assertSame(b2,s.getCurrent());
  assertSame(b1,c.getCurrent());
  assertEquals(2,s.size());
  assertEquals(3,c.size());
 }
 public void test98() {
  s.add(64);
  s.add(32);
  s.add(96);
  s.add(16);
  s.add(48);
  s.add(80);
  s.add(8);
  s.add(24);
  s.add(40);
  s.add(56);
  s.add(72);
  s.add(88);
  for (int i=4; i < 98; i += 8) {
   s.add(i);
  }
  for (int i=2; i < 98; i += 4) {
   s.add(i);
  }
  for (int i=1; i < 98; i += 2) {
   s.add(i);
  }
  SortedSequencec = s.clone();
  assertEquals(97, c.getCurrent().intValue());
  c.start();
  assertEquals(97, c.getCurrent().intValue());
  c.removeCurrent();
  s.start();
  assertEquals(Integer.valueOf(97), s.getCurrent());
  s.advance();
  for (int i=1; i < 97; ++i) {
   assertEquals(97-i,s.getCurrent().intValue());
   assertEquals(97-i,c.getCurrent().intValue());
   s.advance();
   c.advance();
  }
 }
 public void test99() {
  s.add(b1);
  s.add(b2);
  s.add(b3);
  s.start();
  s.advance();
  SortedSequencec = s.clone();
  c.removeCurrent();
  s.add(b4);
  assertEquals(4, s.size());
  assertEquals(2, c.size());
  s.start();
  c.start();
  assertSame(b1, s.getCurrent());
  assertSame(b1, c.getCurrent());
  s.advance();
  c.advance();
  assertSame(b2, s.getCurrent());
  assertSame(b3, c.getCurrent());
  s.advance();
  c.advance();
  assertSame(b3, s.getCurrent());
  assertFalse(c.isCurrent());
 }
}

Related Samples

Explore our Java Assignments samples showcasing fundamental concepts like loops, arrays, object-oriented programming, and more. Discover solutions crafted to aid understanding and inspire learning in Java programming. Perfect for students seeking clarity and guidance in their assignments.

See All Samples

Step-by-Step Guide: Building a JavaScript Report Generator

Java

Word Count

3961 Words

Writer Name:Chloe Wong

Total Orders:590

Satisfaction rate:

Java Breakout Game Development Guide

Java

Word Count

5749 Words