/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections.bidimap;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.SortedMap;
import java.util.SortedSet;
import java.util.TreeMap;
import java.util.TreeSet;
import org.apache.commons.collections.BulkTest;
import org.apache.commons.collections.SortedBidiMap;
import org.apache.commons.collections.map.AbstractTestSortedMap;
/**
* Abstract test class for {@link SortedBidiMap} methods and contracts.
*
* @version $Revision: 646780 $ $Date: 2008-04-10 13:48:07 +0100 (Thu, 10 Apr 2008) $
*
* @author Matthew Hawthorne
* @author Stephen Colebourne
*/
public abstract class AbstractTestSortedBidiMap extends AbstractTestOrderedBidiMap {
protected List sortedKeys = new ArrayList();
protected List sortedValues = new ArrayList();
protected SortedSet sortedNewValues = new TreeSet();
public AbstractTestSortedBidiMap(String testName) {
super(testName);
sortedKeys.addAll(Arrays.asList(getSampleKeys()));
Collections.sort(sortedKeys);
sortedKeys = Collections.unmodifiableList(sortedKeys);
Map map = new TreeMap();
for (int i = 0; i < getSampleKeys().length; i++) {
map.put(getSampleKeys()[i], getSampleValues()[i]);
}
sortedValues.addAll(map.values());
sortedValues = Collections.unmodifiableList(sortedValues);
sortedNewValues.addAll(Arrays.asList(getNewSampleValues()));
}
public AbstractTestSortedBidiMap() {
super();
sortedKeys.addAll(Arrays.asList(getSampleValues()));
Collections.sort(sortedKeys);
sortedKeys = Collections.unmodifiableList(sortedKeys);
Map map = new TreeMap();
for (int i = 0; i < getSampleKeys().length; i++) {
map.put(getSampleValues()[i], getSampleKeys()[i]);
}
sortedValues.addAll(map.values());
sortedValues = Collections.unmodifiableList(sortedValues);
sortedNewValues.addAll(Arrays.asList(getNewSampleValues()));
}
//-----------------------------------------------------------------------
public boolean isAllowNullKey() {
return false;
}
public boolean isAllowNullValue() {
return false;
}
public Map makeConfirmedMap() {
return new TreeMap();
}
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
public void testBidiHeadMapContains() {
// extra test as other tests get complex
SortedBidiMap sm = (SortedBidiMap) makeFullMap();
Iterator it = sm.keySet().iterator();
Object first = it.next();
Object toKey = it.next();
Object second = it.next();
Object firstValue = sm.get(first);
Object secondValue = sm.get(second);
SortedMap head = sm.headMap(toKey);
assertEquals(1, head.size());
assertEquals(true, sm.containsKey(first));
assertEquals(true, head.containsKey(first));
assertEquals(true, sm.containsValue(firstValue));
assertEquals(true, head.containsValue(firstValue));
assertEquals(true, sm.containsKey(second));
assertEquals(false, head.containsKey(second));
assertEquals(true, sm.containsValue(secondValue));
assertEquals(false, head.containsValue(secondValue));
}
//-----------------------------------------------------------------------
public void testBidiClearByHeadMap() {
if (isRemoveSupported() == false) return;
// extra test as other tests get complex
SortedBidiMap sm = (SortedBidiMap) makeFullMap();
Iterator it = sm.keySet().iterator();
Object first = it.next();
Object second = it.next();
Object toKey = it.next();
Object firstValue = sm.get(first);
Object secondValue = sm.get(second);
Object toKeyValue = sm.get(toKey);
SortedMap sub = sm.headMap(toKey);
int size = sm.size();
assertEquals(2, sub.size());
sub.clear();
assertEquals(0, sub.size());
assertEquals(size - 2, sm.size());
assertEquals(size - 2, sm.inverseBidiMap().size());
assertEquals(false, sm.containsKey(first));
assertEquals(false, sm.containsValue(firstValue));
assertEquals(false, sm.inverseBidiMap().containsKey(firstValue));
assertEquals(false, sm.inverseBidiMap().containsValue(first));
assertEquals(false, sub.containsKey(first));
assertEquals(false, sub.containsValue(firstValue));
assertEquals(false, sm.containsKey(second));
assertEquals(false, sm.containsValue(secondValue));
assertEquals(false, sm.inverseBidiMap().containsKey(secondValue));
assertEquals(false, sm.inverseBidiMap().containsValue(second));
assertEquals(false, sub.containsKey(second));
assertEquals(false, sub.containsValue(secondValue));
assertEquals(true, sm.containsKey(toKey));
assertEquals(true, sm.containsValue(toKeyValue));
assertEquals(true, sm.inverseBidiMap().containsKey(toKeyValue));
assertEquals(true, sm.inverseBidiMap().containsValue(toKey));
assertEquals(false, sub.containsKey(toKey));
assertEquals(false, sub.containsValue(toKeyValue));
}
//-----------------------------------------------------------------------
public void testBidiRemoveByHeadMap() {
if (isRemoveSupported() == false) return;
// extra test as other tests get complex
SortedBidiMap sm = (SortedBidiMap) makeFullMap();
Iterator it = sm.keySet().iterator();
Object first = it.next();
Object second = it.next();
Object toKey = it.next();
int size = sm.size();
SortedMap sub = sm.headMap(toKey);
assertEquals(2, sub.size());
assertEquals(true, sm.containsKey(first));
assertEquals(true, sub.containsKey(first));
assertEquals(true, sm.containsKey(second));
assertEquals(true, sub.containsKey(second));
Object firstValue = sub.remove(first);
assertEquals(1, sub.size());
assertEquals(size - 1, sm.size());
assertEquals(size - 1, sm.inverseBidiMap().size());
assertEquals(false, sm.containsKey(first));
assertEquals(false, sm.containsValue(firstValue));
assertEquals(false, sm.inverseBidiMap().containsKey(firstValue));
assertEquals(false, sm.inverseBidiMap().containsValue(first));
assertEquals(false, sub.containsKey(first));
assertEquals(false, sub.containsValue(firstValue));
Object secondValue = sub.remove(second);
assertEquals(0, sub.size());
assertEquals(size - 2, sm.size());
assertEquals(size - 2, sm.inverseBidiMap().size());
assertEquals(false, sm.containsKey(second));
assertEquals(false, sm.containsValue(secondValue));
assertEquals(false, sm.inverseBidiMap().containsKey(secondValue));
assertEquals(false, sm.inverseBidiMap().containsValue(second));
assertEquals(false, sub.containsKey(second));
assertEquals(false, sub.containsValue(secondValue));
}
//-----------------------------------------------------------------------
public void testBidiRemoveByHeadMapEntrySet() {
if (isRemoveSupported() == false) return;
// extra test as other tests get complex
SortedBidiMap sm = (SortedBidiMap) makeFullMap();
Iterator it = sm.keySet().iterator();
Object first = it.next();
Object second = it.next();
Object toKey = it.next();
int size = sm.size();
SortedMap sub = sm.headMap(toKey);
Set set = sub.entrySet();
assertEquals(2, sub.size());
assertEquals(2, set.size());
Iterator it2 = set.iterator();
Map.Entry firstEntry = cloneMapEntry((Map.Entry) it2.next());
Map.Entry secondEntry = cloneMapEntry((Map.Entry) it2.next());
assertEquals(true, sm.containsKey(first));
assertEquals(true, sub.containsKey(first));
assertEquals(true, set.contains(firstEntry));
assertEquals(true, sm.containsKey(second));
assertEquals(true, sub.containsKey(second));
assertEquals(true, set.contains(secondEntry));
set.remove(firstEntry);
assertEquals(1, sub.size());
assertEquals(size - 1, sm.size());
assertEquals(size - 1, sm.inverseBidiMap().size());
assertEquals(false, sm.containsKey(firstEntry.getKey()));
assertEquals(false, sm.containsValue(firstEntry.getValue()));
assertEquals(false, sm.inverseBidiMap().containsKey(firstEntry.getValue()));
assertEquals(false, sm.inverseBidiMap().containsValue(firstEntry.getKey()));
assertEquals(false, sub.containsKey(firstEntry.getKey()));
assertEquals(false, sub.containsValue(firstEntry.getValue()));
assertEquals(false, set.contains(firstEntry));
set.remove(secondEntry);
assertEquals(0, sub.size());
assertEquals(size - 2, sm.size());
assertEquals(size - 2, sm.inverseBidiMap().size());
assertEquals(false, sm.containsKey(secondEntry.getKey()));
assertEquals(false, sm.containsValue(secondEntry.getValue()));
assertEquals(false, sm.inverseBidiMap().containsKey(secondEntry.getValue()));
assertEquals(false, sm.inverseBidiMap().containsValue(secondEntry.getKey()));
assertEquals(false, sub.containsKey(secondEntry.getKey()));
assertEquals(false, sub.containsValue(secondEntry.getValue()));
assertEquals(false, set.contains(secondEntry));
}
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
public void testBidiTailMapContains() {
// extra test as other tests get complex
SortedBidiMap sm = (SortedBidiMap) makeFullMap();
Iterator it = sm.keySet().iterator();
Object first = it.next();
Object fromKey = it.next();
Object second = it.next();
Object firstValue = sm.get(first);
Object fromKeyValue = sm.get(fromKey);
Object secondValue = sm.get(second);
SortedMap sub = sm.tailMap(fromKey);
assertEquals(sm.size() - 1, sub.size());
assertEquals(true, sm.containsKey(first));
assertEquals(false, sub.containsKey(first));
assertEquals(true, sm.containsValue(firstValue));
assertEquals(false, sub.containsValue(firstValue));
assertEquals(true, sm.containsKey(fromKey));
assertEquals(true, sub.containsKey(fromKey));
assertEquals(true, sm.containsValue(fromKeyValue));
assertEquals(true, sub.containsValue(fromKeyValue));
assertEquals(true, sm.containsKey(second));
assertEquals(true, sub.containsKey(second));
assertEquals(true, sm.containsValue(secondValue));
assertEquals(true, sub.containsValue(secondValue));
}
//-----------------------------------------------------------------------
public void testBidiClearByTailMap() {
if (isRemoveSupported() == false) return;
// extra test as other tests get complex
SortedBidiMap sm = (SortedBidiMap) makeFullMap();
Iterator it = sm.keySet().iterator();
it.next();
it.next();
Object first = it.next();
Object fromKey = it.next();
Object second = it.next();
Object firstValue = sm.get(first);
Object fromKeyValue = sm.get(fromKey);
Object secondValue = sm.get(second);
SortedMap sub = sm.tailMap(fromKey);
int size = sm.size();
assertEquals(size - 3, sub.size());
sub.clear();
assertEquals(0, sub.size());
assertEquals(3, sm.size());
assertEquals(3, sm.inverseBidiMap().size());
assertEquals(true, sm.containsKey(first));
assertEquals(true, sm.containsValue(firstValue));
assertEquals(true, sm.inverseBidiMap().containsKey(firstValue));
assertEquals(true, sm.inverseBidiMap().containsValue(first));
assertEquals(false, sub.containsKey(first));
assertEquals(false, sub.containsValue(firstValue));
assertEquals(false, sm.containsKey(fromKey));
assertEquals(false, sm.containsValue(fromKeyValue));
assertEquals(false, sm.inverseBidiMap().containsKey(fromKeyValue));
assertEquals(false, sm.inverseBidiMap().containsValue(fromKey));
assertEquals(false, sub.containsKey(fromKey));
assertEquals(false, sub.containsValue(fromKeyValue));
assertEquals(false, sm.containsKey(second));
assertEquals(false, sm.containsValue(secondValue));
assertEquals(false, sm.inverseBidiMap().containsKey(secondValue));
assertEquals(false, sm.inverseBidiMap().containsValue(second));
assertEquals(false, sub.containsKey(second));
assertEquals(false, sub.containsValue(secondValue));
}
//-----------------------------------------------------------------------
public void testBidiRemoveByTailMap() {
if (isRemoveSupported() == false) return;
// extra test as other tests get complex
SortedBidiMap sm = (SortedBidiMap) makeFullMap();
Iterator it = sm.keySet().iterator();
it.next();
it.next();
Object fromKey = it.next();
Object first = it.next();
Object second = it.next();
int size = sm.size();
SortedMap sub = sm.tailMap(fromKey);
assertEquals(true, sm.containsKey(first));
assertEquals(true, sub.containsKey(first));
assertEquals(true, sm.containsKey(second));
assertEquals(true, sub.containsKey(second));
Object firstValue = sub.remove(first);
assertEquals(size - 3, sub.size());
assertEquals(size - 1, sm.size());
assertEquals(size - 1, sm.inverseBidiMap().size());
assertEquals(false, sm.containsKey(first));
assertEquals(false, sm.containsValue(firstValue));
assertEquals(false, sm.inverseBidiMap().containsKey(firstValue));
assertEquals(false, sm.inverseBidiMap().containsValue(first));
assertEquals(false, sub.containsKey(first));
assertEquals(false, sub.containsValue(firstValue));
Object secondValue = sub.remove(second);
assertEquals(size - 4, sub.size());
assertEquals(size - 2, sm.size());
assertEquals(size - 2, sm.inverseBidiMap().size());
assertEquals(false, sm.containsKey(second));
assertEquals(false, sm.containsValue(secondValue));
assertEquals(false, sm.inverseBidiMap().containsKey(secondValue));
assertEquals(false, sm.inverseBidiMap().containsValue(second));
assertEquals(false, sub.containsKey(second));
assertEquals(false, sub.containsValue(secondValue));
}
//-----------------------------------------------------------------------
public void testBidiRemoveByTailMapEntrySet() {
if (isRemoveSupported() == false) return;
// extra test as other tests get complex
SortedBidiMap sm = (SortedBidiMap) makeFullMap();
Iterator it = sm.keySet().iterator();
it.next();
it.next();
Object fromKey = it.next();
Object first = it.next();
Object second = it.next();
int size = sm.size();
SortedMap sub = sm.tailMap(fromKey);
Set set = sub.entrySet();
Iterator it2 = set.iterator();
Object fromEntry = it2.next();
Map.Entry firstEntry = cloneMapEntry((Map.Entry) it2.next());
Map.Entry secondEntry = cloneMapEntry((Map.Entry) it2.next());
assertEquals(true, sm.containsKey(first));
assertEquals(true, sub.containsKey(first));
assertEquals(true, set.contains(firstEntry));
assertEquals(true, sm.containsKey(second));
assertEquals(true, sub.containsKey(second));
assertEquals(true, set.contains(secondEntry));
set.remove(firstEntry);
assertEquals(size - 3, sub.size());
assertEquals(size - 1, sm.size());
assertEquals(size - 1, sm.inverseBidiMap().size());
assertEquals(false, sm.containsKey(firstEntry.getKey()));
assertEquals(false, sm.containsValue(firstEntry.getValue()));
assertEquals(false, sm.inverseBidiMap().containsKey(firstEntry.getValue()));
assertEquals(false, sm.inverseBidiMap().containsValue(firstEntry.getKey()));
assertEquals(false, sub.containsKey(firstEntry.getKey()));
assertEquals(false, sub.containsValue(firstEntry.getValue()));
assertEquals(false, set.contains(firstEntry));
set.remove(secondEntry);
assertEquals(size - 4, sub.size());
assertEquals(size - 2, sm.size());
assertEquals(size - 2, sm.inverseBidiMap().size());
assertEquals(false, sm.containsKey(secondEntry.getKey()));
assertEquals(false, sm.containsValue(secondEntry.getValue()));
assertEquals(false, sm.inverseBidiMap().containsKey(secondEntry.getValue()));
assertEquals(false, sm.inverseBidiMap().containsValue(secondEntry.getKey()));
assertEquals(false, sub.containsKey(secondEntry.getKey()));
assertEquals(false, sub.containsValue(secondEntry.getValue()));
assertEquals(false, set.contains(secondEntry));
}
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
public void testBidiSubMapContains() {
// extra test as other tests get complex
SortedBidiMap sm = (SortedBidiMap) makeFullMap();
Iterator it = sm.keySet().iterator();
Object first = it.next();
Object fromKey = it.next();
Object second = it.next();
Object toKey = it.next();
Object third = it.next();
Object firstValue = sm.get(first);
Object fromKeyValue = sm.get(fromKey);
Object secondValue = sm.get(second);
Object thirdValue = sm.get(third);
SortedMap sub = sm.subMap(fromKey, toKey);
assertEquals(2, sub.size());
assertEquals(true, sm.containsKey(first));
assertEquals(false, sub.containsKey(first));
assertEquals(true, sm.containsValue(firstValue));
assertEquals(false, sub.containsValue(firstValue));
assertEquals(true, sm.containsKey(fromKey));
assertEquals(true, sub.containsKey(fromKey));
assertEquals(true, sm.containsValue(fromKeyValue));
assertEquals(true, sub.containsValue(fromKeyValue));
assertEquals(true, sm.containsKey(second));
assertEquals(true, sub.containsKey(second));
assertEquals(true, sm.containsValue(secondValue));
assertEquals(true, sub.containsValue(secondValue));
assertEquals(true, sm.containsKey(third));
assertEquals(false, sub.containsKey(third));
assertEquals(true, sm.containsValue(thirdValue));
assertEquals(false, sub.containsValue(thirdValue));
}
//-----------------------------------------------------------------------
public void testBidiClearBySubMap() {
if (isRemoveSupported() == false) return;
// extra test as other tests get complex
SortedBidiMap sm = (SortedBidiMap) makeFullMap();
Iterator it = sm.keySet().iterator();
it.next();
Object fromKey = it.next();
Object first = it.next();
Object second = it.next();
Object toKey = it.next();
Object fromKeyValue = sm.get(fromKey);
Object firstValue = sm.get(first);
Object secondValue = sm.get(second);
Object toKeyValue = sm.get(toKey);
SortedMap sub = sm.subMap(fromKey, toKey);
int size = sm.size();
assertEquals(3, sub.size());
sub.clear();
assertEquals(0, sub.size());
assertEquals(size - 3, sm.size());
assertEquals(size - 3, sm.inverseBidiMap().size());
assertEquals(false, sm.containsKey(fromKey));
assertEquals(false, sm.containsValue(fromKeyValue));
assertEquals(false, sm.inverseBidiMap().containsKey(fromKeyValue));
assertEquals(false, sm.inverseBidiMap().containsValue(fromKey));
assertEquals(false, sub.containsKey(fromKey));
assertEquals(false, sub.containsValue(fromKeyValue));
assertEquals(false, sm.containsKey(first));
assertEquals(false, sm.containsValue(firstValue));
assertEquals(false, sm.inverseBidiMap().containsKey(firstValue));
assertEquals(false, sm.inverseBidiMap().containsValue(first));
assertEquals(false, sub.containsKey(first));
assertEquals(false, sub.containsValue(firstValue));
assertEquals(false, sm.containsKey(second));
assertEquals(false, sm.containsValue(secondValue));
assertEquals(false, sm.inverseBidiMap().containsKey(secondValue));
assertEquals(false, sm.inverseBidiMap().containsValue(second));
assertEquals(false, sub.containsKey(second));
assertEquals(false, sub.containsValue(secondValue));
assertEquals(true, sm.containsKey(toKey));
assertEquals(true, sm.containsValue(toKeyValue));
assertEquals(true, sm.inverseBidiMap().containsKey(toKeyValue));
assertEquals(true, sm.inverseBidiMap().containsValue(toKey));
assertEquals(false, sub.containsKey(toKey));
assertEquals(false, sub.containsValue(toKeyValue));
}
//-----------------------------------------------------------------------
public void testBidiRemoveBySubMap() {
if (isRemoveSupported() == false) return;
// extra test as other tests get complex
SortedBidiMap sm = (SortedBidiMap) makeFullMap();
Iterator it = sm.keySet().iterator();
it.next();
it.next();
Object fromKey = it.next();
Object first = it.next();
Object second = it.next();
Object toKey = it.next();
int size = sm.size();
SortedMap sub = sm.subMap(fromKey, toKey);
assertEquals(true, sm.containsKey(first));
assertEquals(true, sub.containsKey(first));
assertEquals(true, sm.containsKey(second));
assertEquals(true, sub.containsKey(second));
Object firstValue = sub.remove(first);
assertEquals(2, sub.size());
assertEquals(size - 1, sm.size());
assertEquals(size - 1, sm.inverseBidiMap().size());
assertEquals(false, sm.containsKey(first));
assertEquals(false, sm.containsValue(firstValue));
assertEquals(false, sm.inverseBidiMap().containsKey(firstValue));
assertEquals(false, sm.inverseBidiMap().containsValue(first));
assertEquals(false, sub.containsKey(first));
assertEquals(false, sub.containsValue(firstValue));
Object secondValue = sub.remove(second);
assertEquals(1, sub.size());
assertEquals(size - 2, sm.size());
assertEquals(size - 2, sm.inverseBidiMap().size());
assertEquals(false, sm.containsKey(second));
assertEquals(false, sm.containsValue(secondValue));
assertEquals(false, sm.inverseBidiMap().containsKey(secondValue));
assertEquals(false, sm.inverseBidiMap().containsValue(second));
assertEquals(false, sub.containsKey(second));
assertEquals(false, sub.containsValue(secondValue));
}
//-----------------------------------------------------------------------
public void testBidiRemoveBySubMapEntrySet() {
if (isRemoveSupported() == false) return;
// extra test as other tests get complex
SortedBidiMap sm = (SortedBidiMap) makeFullMap();
Iterator it = sm.keySet().iterator();
it.next();
it.next();
Object fromKey = it.next();
Object first = it.next();
Object second = it.next();
Object toKey = it.next();
int size = sm.size();
SortedMap sub = sm.subMap(fromKey, toKey);
Set set = sub.entrySet();
assertEquals(3, set.size());
Iterator it2 = set.iterator();
Object fromEntry = it2.next();
Map.Entry firstEntry = cloneMapEntry((Map.Entry) it2.next());
Map.Entry secondEntry = cloneMapEntry((Map.Entry) it2.next());
assertEquals(true, sm.containsKey(first));
assertEquals(true, sub.containsKey(first));
assertEquals(true, set.contains(firstEntry));
assertEquals(true, sm.containsKey(second));
assertEquals(true, sub.containsKey(second));
assertEquals(true, set.contains(secondEntry));
set.remove(firstEntry);
assertEquals(2, sub.size());
assertEquals(size - 1, sm.size());
assertEquals(size - 1, sm.inverseBidiMap().size());
assertEquals(false, sm.containsKey(firstEntry.getKey()));
assertEquals(false, sm.containsValue(firstEntry.getValue()));
assertEquals(false, sm.inverseBidiMap().containsKey(firstEntry.getValue()));
assertEquals(false, sm.inverseBidiMap().containsValue(firstEntry.getKey()));
assertEquals(false, sub.containsKey(firstEntry.getKey()));
assertEquals(false, sub.containsValue(firstEntry.getValue()));
assertEquals(false, set.contains(firstEntry));
set.remove(secondEntry);
assertEquals(1, sub.size());
assertEquals(size - 2, sm.size());
assertEquals(size - 2, sm.inverseBidiMap().size());
assertEquals(false, sm.containsKey(secondEntry.getKey()));
assertEquals(false, sm.containsValue(secondEntry.getValue()));
assertEquals(false, sm.inverseBidiMap().containsKey(secondEntry.getValue()));
assertEquals(false, sm.inverseBidiMap().containsValue(secondEntry.getKey()));
assertEquals(false, sub.containsKey(secondEntry.getKey()));
assertEquals(false, sub.containsValue(secondEntry.getValue()));
assertEquals(false, set.contains(secondEntry));
}
//-----------------------------------------------------------------------
public BulkTest bulkTestHeadMap() {
return new AbstractTestSortedMap.TestHeadMap(this);
}
public BulkTest bulkTestTailMap() {
return new AbstractTestSortedMap.TestTailMap(this);
}
public BulkTest bulkTestSubMap() {
return new AbstractTestSortedMap.TestSubMap(this);
}
}