コード例 #1
0
  public void testIsNDimensional() {
    ReflectClass arrayOfArrayOfString = reflectClass(String[][].class);
    Assert.isTrue(arrayOfArrayOfString.isArray());

    final ReflectClass arrayOfString = reflectClass(String[].class);
    Assert.areSame(arrayOfString, arrayOfArrayOfString.getComponentType());
    Assert.isTrue(arrayReflector().isNDimensional(arrayOfArrayOfString));
    Assert.isFalse(arrayReflector().isNDimensional(arrayOfString));
  }
コード例 #2
0
 private void peek(Item original, int depth) {
   Item peeked = (Item) db().peekPersisted(original, depth, true);
   for (int i = 0; i <= depth; i++) {
     Assert.isNotNull(peeked, "Failed to peek at child " + i + " at depth " + depth);
     Assert.isFalse(db().isStored(peeked));
     peeked = peeked.child;
   }
   Assert.isNull(peeked);
 }
コード例 #3
0
  public void testNoItemInIndex() {

    StoredClass storedClass = db().storedClass(Item.class);
    Assert.isFalse(storedClass.hasClassIndex());

    assertNoItemFoundByQuery();

    db().commit();
    assertNoItemFoundByQuery();
  }
コード例 #4
0
 public void testDoesNotAcceptOptOutAllButNetworkingCS() {
   Assert.isFalse(subject.accept(OptOutAllButNetworkingCSTest.class));
 }
コード例 #5
0
 public void testDoesNotAcceptOptOutCS() {
   Assert.isFalse(subject.accept(OptOutTest.class));
 }
コード例 #6
0
 public void testDoesNotAcceptRegularTest() {
   Assert.isFalse(subject.accept(RegularTest.class));
 }
コード例 #7
0
  /** @deprecated using deprecated api */
  private void runElementTest(Data data, boolean onOriginal) throws Exception {

    Map otherMap = new HashMap();

    AtomData atom = null;

    tDefaultValues(data);

    int itCount = 0;
    Iterator i = data.i_map.keySet().iterator();
    while (i.hasNext()) {
      String str = (String) i.next();
      itCount++;
      atom = (AtomData) data.i_map.get(str);
      Assert.areEqual(str, atom.name);
      otherMap.put(str, atom);
    }
    Assert.areEqual(DEFAULT.length, itCount);

    Assert.areEqual(DEFAULT.length, data.i_map.size());
    Assert.isFalse(data.i_map.isEmpty());
    db().deactivate(data.i_map, Integer.MAX_VALUE);
    data.i_map.get("great");
    Assert.areEqual("great", ((AtomData) data.i_map.get("great")).name);
    db().deactivate(data.i_map, Integer.MAX_VALUE);

    if (onOriginal) {
      Query q = newQuery();
      Data template = new Data();
      template.i_map = db().collections().newHashMap(1);
      template.i_map.put("cool", new AtomData("cool"));
      q.constrain(template);
      ObjectSet qResult = q.execute();
      Assert.areEqual(1, qResult.size());
      Assert.areEqual(data, qResult.next());
    }

    Assert.isTrue(data.i_map.keySet().containsAll(otherMap.keySet()));

    Object[] arr = data.i_map.keySet().toArray();
    tDefaultArray(arr);

    String[] cmp = new String[DEFAULT.length];
    System.arraycopy(DEFAULT, 0, cmp, 0, DEFAULT.length);

    i = data.i_map.keySet().iterator();
    while (i.hasNext()) {
      String str = (String) i.next();
      boolean found = false;
      for (int j = 0; j < cmp.length; j++) {
        if (str.equals(cmp[j])) {
          cmp[j] = null;
          found = true;
        }
      }
      Assert.isTrue(found);
    }

    for (int j = 0; j < cmp.length; j++) {
      Assert.isNull(cmp[j]);
    }

    db().deactivate(data.i_map, Integer.MAX_VALUE);
    Assert.isFalse(data.i_map.isEmpty());
    db().deactivate(data.i_map, Integer.MAX_VALUE);
    data.i_map.put("yup", new AtomData("yup"));

    db().store(data.i_map);
    db().store(data.i_map);
    db().store(data.i_map);
    db().store(data.i_helper);
    db().store(data.i_helper);
    db().store(data.i_helper);
    db().commit();

    Assert.areEqual(4, data.i_map.size());

    atom = (AtomData) data.i_map.get("yup");
    Assert.areEqual("yup", atom.name);

    AtomData removed = (AtomData) data.i_map.remove("great");

    Assert.areEqual("great", removed.name);
    Assert.isNull(data.i_map.remove("great"));
    db().deactivate(data.i_map, Integer.MAX_VALUE);
    Assert.areEqual(3, data.i_map.size());

    Assert.isTrue(data.i_map.keySet().removeAll(otherMap.keySet()));
    db().deactivate(data.i_map, Integer.MAX_VALUE);
    Assert.isFalse(data.i_map.keySet().removeAll(otherMap.keySet()));
    Assert.areEqual(1, data.i_map.size());
    i = data.i_map.keySet().iterator();
    String str = (String) i.next();
    Assert.areEqual("yup", str);
    Assert.isFalse(i.hasNext());

    data.i_map.clear();
    Assert.isTrue(data.i_map.isEmpty());
    Assert.areEqual(0, data.i_map.size());

    setDefaultValues(data.i_map);

    String[] strArr = new String[1];
    strArr = (String[]) data.i_map.keySet().toArray(strArr);
    tDefaultArray(strArr);

    data.i_map.clear();
    data.i_map.put("zero", "zero");

    for (int j = 0; j < COUNT; j++) {
      data.i_map.put(MORE + j, new AtomData(MORE + j));
    }
    Assert.areEqual(COUNT + 1, data.i_map.size());
    lookupLast(data);

    db().deactivate(data.i_map, Integer.MAX_VALUE);
    lookupLast(data);
    lookupLast(data);

    reopen();
    restoreMembers(data);
    lookupLast(data);

    atom = new AtomData("double");

    data.i_map.put("double", atom);

    int previousSize = data.i_map.size();

    db().deactivate(data.i_map, Integer.MAX_VALUE);

    AtomData doubleAtom = (AtomData) data.i_map.put("double", new AtomData("double"));
    Assert.areSame(atom, doubleAtom);

    Assert.areEqual(previousSize, data.i_map.size());
    data.i_map.put("double", doubleAtom);

    db().commit();

    data.i_map.put("rollBack", "rollBack");
    data.i_map.put("double", new AtomData("nono"));

    db().rollback();
    Assert.isNull(data.i_map.get("rollBack"));
    Assert.areEqual(previousSize, data.i_map.size());
    atom = (AtomData) data.i_map.get("double");
    Assert.areSame(atom, doubleAtom);
    Assert.isTrue(data.i_map.containsKey("double"));
    Assert.isFalse(data.i_map.containsKey("rollBack"));

    otherMap.clear();
    otherMap.put("other1", doubleAtom);
    otherMap.put("other2", doubleAtom);

    data.i_map.putAll(otherMap);
    db().deactivate(data.i_map, Integer.MAX_VALUE);

    Assert.areSame(doubleAtom, data.i_map.get("other1"));
    Assert.areSame(doubleAtom, data.i_map.get("other2"));

    data.i_map.clear();
    Assert.areEqual(0, data.i_map.size());
    setDefaultValues(data.i_map);

    int j = 0;
    i = data.i_map.keySet().iterator();
    while (i.hasNext()) {
      String key = (String) i.next();
      if (key.equals("cool")) {
        i.remove();
      }
      j++;
    }
    Assert.areEqual(2, data.i_map.size());
    Assert.isFalse(data.i_map.containsKey("cool"));
    Assert.areEqual(3, j);

    data.i_map.put("double", doubleAtom);
    ((Db4oMap) data.i_map).deleteRemoved(true);
    data.i_map.keySet().remove("double");
    Assert.isFalse(db().isStored(doubleAtom));
    ((Db4oMap) data.i_map).deleteRemoved(false);

    data.i_map.clear();
    Assert.areEqual(0, data.i_map.size());
    setDefaultValues(data.i_map);
  }
コード例 #8
0
 public void operate(ArrayList4<Integer> list) {
   Assert.isFalse(list.contains(new Integer(ArrayList4Asserter.CAPACITY)));
 }