From 72650d4cc41c64136d064967d7fec3726d850fee Mon Sep 17 00:00:00 2001
From: Ludovic Poitou <ludovic.poitou@forgerock.com>
Date: Thu, 14 Oct 2010 11:52:28 +0000
Subject: [PATCH] Multiple enhancements and bug fixes to the SDK (update from OpenDS by matthew_swift):

---
 sdk/tests/unit-tests-testng/src/org/opends/sdk/LinkedAttributeTestCase.java |  417 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 files changed, 417 insertions(+), 0 deletions(-)

diff --git a/sdk/tests/unit-tests-testng/src/org/opends/sdk/LinkedAttributeTestCase.java b/sdk/tests/unit-tests-testng/src/org/opends/sdk/LinkedAttributeTestCase.java
index 9a84966..4ec0f6b 100644
--- a/sdk/tests/unit-tests-testng/src/org/opends/sdk/LinkedAttributeTestCase.java
+++ b/sdk/tests/unit-tests-testng/src/org/opends/sdk/LinkedAttributeTestCase.java
@@ -29,6 +29,11 @@
 
 
 
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+
 import org.opends.sdk.schema.Schema;
 import org.testng.Assert;
 import org.testng.annotations.Test;
@@ -66,4 +71,416 @@
     Assert.assertTrue(attribute.remove(ByteString.valueOf("another value")));
     Assert.assertEquals(attribute.size(), 0);
   }
+
+
+
+  @Test
+  public void testAdd()
+  {
+    Attribute a = new LinkedAttribute("test");
+    Assert.assertTrue(a.add(ByteString.valueOf("value1")));
+    Assert.assertFalse(a.add(ByteString.valueOf("value1")));
+    Assert.assertTrue(a.add(ByteString.valueOf("value2")));
+    Assert.assertFalse(a.add(ByteString.valueOf("value2")));
+    Assert.assertTrue(a.add(ByteString.valueOf("value3")));
+    Assert.assertFalse(a.add(ByteString.valueOf("value3")));
+    Assert.assertEquals(a.size(), 3);
+    Iterator<ByteString> i = a.iterator();
+    Assert.assertEquals(i.next(), ByteString.valueOf("value1"));
+    Assert.assertEquals(i.next(), ByteString.valueOf("value2"));
+    Assert.assertEquals(i.next(), ByteString.valueOf("value3"));
+    Assert.assertFalse(i.hasNext());
+  }
+
+
+
+  @Test
+  public void testAddAll()
+  {
+    // addAll to an empty attribute.
+    Attribute a = new LinkedAttribute("test");
+    Assert.assertFalse(a.addAll(Collections.<ByteString> emptyList(), null));
+    Iterator<ByteString> i = a.iterator();
+    Assert.assertFalse(i.hasNext());
+
+    a = new LinkedAttribute("test");
+    Assert.assertTrue(a.addAll(Arrays.asList(ByteString.valueOf("value1")),
+        null));
+    i = a.iterator();
+    Assert.assertEquals(i.next(), ByteString.valueOf("value1"));
+    Assert.assertFalse(i.hasNext());
+
+    a = new LinkedAttribute("test");
+    Assert.assertTrue(a.addAll(
+        Arrays.asList(ByteString.valueOf("value1"),
+            ByteString.valueOf("value2")), null));
+    i = a.iterator();
+    Assert.assertEquals(i.next(), ByteString.valueOf("value1"));
+    Assert.assertEquals(i.next(), ByteString.valueOf("value2"));
+    Assert.assertFalse(i.hasNext());
+
+    // addAll to a single-valued attribute.
+    a = new LinkedAttribute("test", ByteString.valueOf("value1"));
+    Assert.assertFalse(a.addAll(Collections.<ByteString> emptyList(), null));
+    i = a.iterator();
+    Assert.assertEquals(i.next(), ByteString.valueOf("value1"));
+    Assert.assertFalse(i.hasNext());
+
+    a = new LinkedAttribute("test", ByteString.valueOf("value1"));
+    Assert.assertTrue(a.addAll(Arrays.asList(ByteString.valueOf("value2")),
+        null));
+    i = a.iterator();
+    Assert.assertEquals(i.next(), ByteString.valueOf("value1"));
+    Assert.assertEquals(i.next(), ByteString.valueOf("value2"));
+    Assert.assertFalse(i.hasNext());
+
+    a = new LinkedAttribute("test", ByteString.valueOf("value1"));
+    Assert.assertTrue(a.addAll(
+        Arrays.asList(ByteString.valueOf("value2"),
+            ByteString.valueOf("value3")), null));
+    i = a.iterator();
+    Assert.assertEquals(i.next(), ByteString.valueOf("value1"));
+    Assert.assertEquals(i.next(), ByteString.valueOf("value2"));
+    Assert.assertEquals(i.next(), ByteString.valueOf("value3"));
+    Assert.assertFalse(i.hasNext());
+
+    // addAll to a multi-valued attribute.
+    a = new LinkedAttribute("test", ByteString.valueOf("value1"),
+        ByteString.valueOf("value2"));
+    Assert.assertFalse(a.addAll(Collections.<ByteString> emptyList(), null));
+    i = a.iterator();
+    Assert.assertEquals(i.next(), ByteString.valueOf("value1"));
+    Assert.assertEquals(i.next(), ByteString.valueOf("value2"));
+    Assert.assertFalse(i.hasNext());
+
+    a = new LinkedAttribute("test", ByteString.valueOf("value1"),
+        ByteString.valueOf("value2"));
+    Assert.assertTrue(a.addAll(Arrays.asList(ByteString.valueOf("value3")),
+        null));
+    i = a.iterator();
+    Assert.assertEquals(i.next(), ByteString.valueOf("value1"));
+    Assert.assertEquals(i.next(), ByteString.valueOf("value2"));
+    Assert.assertEquals(i.next(), ByteString.valueOf("value3"));
+    Assert.assertFalse(i.hasNext());
+
+    a = new LinkedAttribute("test", ByteString.valueOf("value1"),
+        ByteString.valueOf("value2"));
+    Assert.assertTrue(a.addAll(
+        Arrays.asList(ByteString.valueOf("value3"),
+            ByteString.valueOf("value4")), null));
+    i = a.iterator();
+    Assert.assertEquals(i.next(), ByteString.valueOf("value1"));
+    Assert.assertEquals(i.next(), ByteString.valueOf("value2"));
+    Assert.assertEquals(i.next(), ByteString.valueOf("value3"));
+    Assert.assertEquals(i.next(), ByteString.valueOf("value4"));
+    Assert.assertFalse(i.hasNext());
+  }
+
+
+
+  @Test
+  public void testClear()
+  {
+    Attribute a = new LinkedAttribute("test");
+    Assert.assertTrue(a.isEmpty());
+    Assert.assertEquals(a.size(), 0);
+    a.clear();
+    Assert.assertTrue(a.isEmpty());
+    Assert.assertEquals(a.size(), 0);
+
+    a.add(ByteString.valueOf("value1"));
+    Assert.assertFalse(a.isEmpty());
+    Assert.assertEquals(a.size(), 1);
+    a.clear();
+    Assert.assertTrue(a.isEmpty());
+    Assert.assertEquals(a.size(), 0);
+
+    a.add(ByteString.valueOf("value1"));
+    a.add(ByteString.valueOf("value2"));
+    Assert.assertFalse(a.isEmpty());
+    Assert.assertEquals(a.size(), 2);
+    a.clear();
+    Assert.assertTrue(a.isEmpty());
+    Assert.assertEquals(a.size(), 0);
+
+    a.add(ByteString.valueOf("value1"));
+    a.add(ByteString.valueOf("value2"));
+    a.add(ByteString.valueOf("value3"));
+    Assert.assertFalse(a.isEmpty());
+    Assert.assertEquals(a.size(), 3);
+    a.clear();
+    Assert.assertTrue(a.isEmpty());
+    Assert.assertEquals(a.size(), 0);
+  }
+
+
+
+  @Test
+  public void testContains()
+  {
+    Attribute a = new LinkedAttribute("test");
+    Assert.assertFalse(a.contains(ByteString.valueOf("value4")));
+
+    a.add(ByteString.valueOf("value1"));
+    Assert.assertTrue(a.contains(ByteString.valueOf("value1")));
+    Assert.assertFalse(a.contains(ByteString.valueOf("value4")));
+
+    a.add(ByteString.valueOf("value2"));
+    Assert.assertTrue(a.contains(ByteString.valueOf("value1")));
+    Assert.assertTrue(a.contains(ByteString.valueOf("value2")));
+    Assert.assertFalse(a.contains(ByteString.valueOf("value4")));
+
+    a.add(ByteString.valueOf("value3"));
+    Assert.assertTrue(a.contains(ByteString.valueOf("value1")));
+    Assert.assertTrue(a.contains(ByteString.valueOf("value2")));
+    Assert.assertTrue(a.contains(ByteString.valueOf("value3")));
+    Assert.assertFalse(a.contains(ByteString.valueOf("value4")));
+  }
+
+
+
+  @Test
+  public void testContainsAll()
+  {
+    Attribute a = new LinkedAttribute("test");
+    Assert.assertTrue(a.containsAll(Collections.<ByteString> emptyList()));
+    Assert
+        .assertFalse(a.containsAll(Arrays.asList(ByteString.valueOf("value1"))));
+    Assert.assertFalse(a.containsAll(Arrays.asList(
+        ByteString.valueOf("value1"), ByteString.valueOf("value2"))));
+    Assert.assertFalse(a.containsAll(Arrays.asList(
+        ByteString.valueOf("value1"), ByteString.valueOf("value2"),
+        ByteString.valueOf("value3"))));
+
+    a.add(ByteString.valueOf("value1"));
+    Assert.assertTrue(a.containsAll(Collections.<ByteString> emptyList()));
+    Assert
+        .assertTrue(a.containsAll(Arrays.asList(ByteString.valueOf("value1"))));
+    Assert.assertFalse(a.containsAll(Arrays.asList(
+        ByteString.valueOf("value1"), ByteString.valueOf("value2"))));
+    Assert.assertFalse(a.containsAll(Arrays.asList(
+        ByteString.valueOf("value1"), ByteString.valueOf("value2"),
+        ByteString.valueOf("value3"))));
+
+    a.add(ByteString.valueOf("value2"));
+    Assert.assertTrue(a.containsAll(Collections.<ByteString> emptyList()));
+    Assert
+        .assertTrue(a.containsAll(Arrays.asList(ByteString.valueOf("value1"))));
+    Assert.assertTrue(a.containsAll(Arrays.asList(ByteString.valueOf("value1"),
+        ByteString.valueOf("value2"))));
+    Assert.assertFalse(a.containsAll(Arrays.asList(
+        ByteString.valueOf("value1"), ByteString.valueOf("value2"),
+        ByteString.valueOf("value3"))));
+  }
+
+
+
+  @Test
+  public void testFirstValue()
+  {
+    Attribute a = new LinkedAttribute("test");
+    try
+    {
+      a.firstValue();
+      Assert.fail("Expected NoSuchElementException");
+    }
+    catch (NoSuchElementException e)
+    {
+      // Expected.
+    }
+
+    a = new LinkedAttribute("test", ByteString.valueOf("value1"));
+    Assert.assertEquals(a.firstValue(), ByteString.valueOf("value1"));
+
+    a = new LinkedAttribute("test", ByteString.valueOf("value1"),
+        ByteString.valueOf("value2"));
+    Assert.assertEquals(a.firstValue(), ByteString.valueOf("value1"));
+
+    a = new LinkedAttribute("test", ByteString.valueOf("value2"),
+        ByteString.valueOf("value1"));
+    Assert.assertEquals(a.firstValue(), ByteString.valueOf("value2"));
+  }
+
+
+
+  @Test
+  public void testGetAttributeDescription()
+  {
+    AttributeDescription ad = AttributeDescription.valueOf("test");
+    Attribute a = new LinkedAttribute(ad);
+    Assert.assertEquals(a.getAttributeDescription(), ad);
+  }
+
+
+
+  @Test
+  public void testIterator()
+  {
+    Attribute a = new LinkedAttribute("test");
+    Iterator<ByteString> i = a.iterator();
+    Assert.assertFalse(i.hasNext());
+
+    a = new LinkedAttribute("test", ByteString.valueOf("value1"));
+    i = a.iterator();
+    Assert.assertTrue(i.hasNext());
+    Assert.assertEquals(i.next(), ByteString.valueOf("value1"));
+    Assert.assertFalse(i.hasNext());
+
+    a = new LinkedAttribute("test", ByteString.valueOf("value1"),
+        ByteString.valueOf("value2"));
+    i = a.iterator();
+    Assert.assertTrue(i.hasNext());
+    Assert.assertEquals(i.next(), ByteString.valueOf("value1"));
+    Assert.assertTrue(i.hasNext());
+    Assert.assertEquals(i.next(), ByteString.valueOf("value2"));
+    Assert.assertFalse(i.hasNext());
+  }
+
+
+
+  @Test
+  public void testRemove()
+  {
+    Attribute a = new LinkedAttribute("test");
+    Assert.assertFalse(a.remove(ByteString.valueOf("value1")));
+    Iterator<ByteString> i = a.iterator();
+    Assert.assertFalse(i.hasNext());
+
+    a = new LinkedAttribute("test", ByteString.valueOf("value1"));
+    Assert.assertFalse(a.remove(ByteString.valueOf("value2")));
+    i = a.iterator();
+    Assert.assertTrue(i.hasNext());
+    Assert.assertEquals(i.next(), ByteString.valueOf("value1"));
+    Assert.assertFalse(i.hasNext());
+    Assert.assertTrue(a.remove(ByteString.valueOf("value1")));
+    i = a.iterator();
+    Assert.assertFalse(i.hasNext());
+
+    a = new LinkedAttribute("test", ByteString.valueOf("value1"),
+        ByteString.valueOf("value2"));
+    Assert.assertFalse(a.remove(ByteString.valueOf("value3")));
+    i = a.iterator();
+    Assert.assertTrue(i.hasNext());
+    Assert.assertEquals(i.next(), ByteString.valueOf("value1"));
+    Assert.assertEquals(i.next(), ByteString.valueOf("value2"));
+    Assert.assertFalse(i.hasNext());
+    Assert.assertTrue(a.remove(ByteString.valueOf("value1")));
+    i = a.iterator();
+    Assert.assertTrue(i.hasNext());
+    Assert.assertEquals(i.next(), ByteString.valueOf("value2"));
+    Assert.assertFalse(i.hasNext());
+    Assert.assertTrue(a.remove(ByteString.valueOf("value2")));
+    i = a.iterator();
+    Assert.assertFalse(i.hasNext());
+  }
+
+
+
+  @Test
+  public void testRemoveAll()
+  {
+    // removeAll from an empty attribute.
+    Attribute a = new LinkedAttribute("test");
+    Assert.assertFalse(a.removeAll(Collections.<ByteString> emptyList(), null));
+    Iterator<ByteString> i = a.iterator();
+    Assert.assertFalse(i.hasNext());
+
+    a = new LinkedAttribute("test");
+    Assert.assertFalse(a.removeAll(Arrays.asList(ByteString.valueOf("value1")),
+        null));
+    i = a.iterator();
+    Assert.assertFalse(i.hasNext());
+
+    a = new LinkedAttribute("test");
+    Assert.assertFalse(a.removeAll(Arrays.asList(ByteString.valueOf("value1"),
+        ByteString.valueOf("value2"))));
+    i = a.iterator();
+    Assert.assertFalse(i.hasNext());
+
+    // removeAll from single-valued attribute.
+    a = new LinkedAttribute("test", ByteString.valueOf("value1"));
+    Assert.assertFalse(a.removeAll(Collections.<ByteString> emptyList(), null));
+    i = a.iterator();
+    Assert.assertTrue(i.hasNext());
+    Assert.assertEquals(i.next(), ByteString.valueOf("value1"));
+    Assert.assertFalse(i.hasNext());
+
+    a = new LinkedAttribute("test", ByteString.valueOf("value1"));
+    Assert.assertTrue(a.removeAll(Arrays.asList(ByteString.valueOf("value1")),
+        null));
+    i = a.iterator();
+    Assert.assertFalse(i.hasNext());
+
+    a = new LinkedAttribute("test", ByteString.valueOf("value1"));
+    Assert.assertTrue(a.removeAll(Arrays.asList(ByteString.valueOf("value1"),
+        ByteString.valueOf("value2"))));
+    i = a.iterator();
+    Assert.assertFalse(i.hasNext());
+
+    // removeAll from multi-valued attribute.
+    a = new LinkedAttribute("test", ByteString.valueOf("value1"),
+        ByteString.valueOf("value2"), ByteString.valueOf("value3"),
+        ByteString.valueOf("value4"));
+    Assert.assertFalse(a.removeAll(Collections.<ByteString> emptyList(), null));
+    i = a.iterator();
+    Assert.assertTrue(i.hasNext());
+    Assert.assertEquals(i.next(), ByteString.valueOf("value1"));
+    Assert.assertEquals(i.next(), ByteString.valueOf("value2"));
+    Assert.assertEquals(i.next(), ByteString.valueOf("value3"));
+    Assert.assertEquals(i.next(), ByteString.valueOf("value4"));
+    Assert.assertFalse(i.hasNext());
+
+    a = new LinkedAttribute("test", ByteString.valueOf("value1"),
+        ByteString.valueOf("value2"), ByteString.valueOf("value3"),
+        ByteString.valueOf("value4"));
+    Assert.assertTrue(a.removeAll(Arrays.asList(ByteString.valueOf("value1")),
+        null));
+    i = a.iterator();
+    Assert.assertTrue(i.hasNext());
+    Assert.assertEquals(i.next(), ByteString.valueOf("value2"));
+    Assert.assertEquals(i.next(), ByteString.valueOf("value3"));
+    Assert.assertEquals(i.next(), ByteString.valueOf("value4"));
+    Assert.assertFalse(i.hasNext());
+
+    a = new LinkedAttribute("test", ByteString.valueOf("value1"),
+        ByteString.valueOf("value2"), ByteString.valueOf("value3"),
+        ByteString.valueOf("value4"));
+    Assert.assertTrue(a.removeAll(
+        Arrays.asList(ByteString.valueOf("value1"),
+            ByteString.valueOf("value2")), null));
+    i = a.iterator();
+    Assert.assertTrue(i.hasNext());
+    Assert.assertEquals(i.next(), ByteString.valueOf("value3"));
+    Assert.assertEquals(i.next(), ByteString.valueOf("value4"));
+    Assert.assertFalse(i.hasNext());
+
+    a = new LinkedAttribute("test", ByteString.valueOf("value1"),
+        ByteString.valueOf("value2"), ByteString.valueOf("value3"),
+        ByteString.valueOf("value4"));
+    Assert.assertTrue(a.removeAll(
+        Arrays.asList(ByteString.valueOf("value1"),
+            ByteString.valueOf("value2"), ByteString.valueOf("value3")), null));
+    i = a.iterator();
+    Assert.assertTrue(i.hasNext());
+    Assert.assertEquals(i.next(), ByteString.valueOf("value4"));
+    Assert.assertFalse(i.hasNext());
+
+    a = new LinkedAttribute("test", ByteString.valueOf("value1"),
+        ByteString.valueOf("value2"), ByteString.valueOf("value3"),
+        ByteString.valueOf("value4"));
+    Assert.assertTrue(a.removeAll(Arrays.asList(ByteString.valueOf("value1"),
+        ByteString.valueOf("value2"), ByteString.valueOf("value3"),
+        ByteString.valueOf("value4")), null));
+    i = a.iterator();
+    Assert.assertFalse(i.hasNext());
+
+    a = new LinkedAttribute("test", ByteString.valueOf("value1"),
+        ByteString.valueOf("value2"), ByteString.valueOf("value3"),
+        ByteString.valueOf("value4"));
+    Assert.assertTrue(a.removeAll(Arrays.asList(ByteString.valueOf("value1"),
+        ByteString.valueOf("value2"), ByteString.valueOf("value3"),
+        ByteString.valueOf("value4"), ByteString.valueOf("value5")), null));
+    i = a.iterator();
+    Assert.assertFalse(i.hasNext());
+  }
 }

--
Gitblit v1.10.0