@Override

    public Store<String, String, String> getStore() {

        return SerializingStore.wrap(new InMemoryStorageEngine<ByteArray, byte[], byte[]>("test"),

    }

    public void testKeyIterationWithSerialization() {

        StorageEngine<ByteArray, byte[], byte[]> store = getStorageEngine();

        StorageEngine<String, String, String> stringStore = new SerializingStorageEngine<String, String, String>(store,

        Map<String, String> vals = ImmutableMap.of("a", "a", "b", "b", "c", "c", "d", "d", "e", "e");

        for(Map.Entry<String, String> entry: vals.entrySet())

            stringStore.put(entry.getKey(), new Versioned<String>(entry.getValue()), null);

        ClosableIterator<String> iter = stringStore.keys();

        int count = 0;

    public void testIterationWithSerialization() {

        StorageEngine<ByteArray, byte[], byte[]> store = getStorageEngine();

        StorageEngine<String, String, String> stringStore = SerializingStorageEngine.wrap(store,

        Map<String, String> vals = ImmutableMap.of("a", "a", "b", "b", "c", "c", "d", "d", "e", "e");

        for(Map.Entry<String, String> entry: vals.entrySet())

            stringStore.put(entry.getKey(), new Versioned<String>(entry.getValue()), null);

        ClosableIterator<Pair<String, Versioned<String>>> iter = stringStore.entries();

        int count = 0;

    @Before

    public void setUp() throws Exception {

        this.nodeId = 0;

        this.time = SystemTime.INSTANCE;

        MockStoreClientFactory factory = new MockStoreClientFactory(serializer,

                                                                    serializer,

                                                                    null,

                                                                    serializer,

                                                                    nodeId,

    }

    @Test

    public void testCaching() {

                                                              null);

        StoreClientFactory spyFactory = spy(inner);

        StoreClientFactory cachingFactory = new CachingStoreClientFactory(spyFactory);

        TimeBasedInconsistencyResolver<Object> resolver = new TimeBasedInconsistencyResolver<Object>();

    }

    @Test

    public void testBootstrapAll() {

                                                              null);

        final DefaultStoreClient<Object, Object> aStoreClient = spy((DefaultStoreClient<Object, Object>) inner.getStoreClient("test1"));

        final DefaultStoreClient<Object, Object> bStoreClient = spy((DefaultStoreClient<Object, Object>) inner.getStoreClient("test2"));

        StoreClientFactory mocked = mock(StoreClientFactory.class);

                                                                                                             SystemStoreConstants.SystemStoreName.voldsys$_metadata_version_persistence.name(),

                                                                                                             partitionIdList,

                                                                                                             null,

                                                                                                             true);

        String keyObject = null;

        String valueObject = null;

        while(entriesIterator.hasNext()) {

            try {

                Pair<ByteArray, Versioned<byte[]>> kvPair = entriesIterator.next();

                byte[] keyBytes = kvPair.getFirst().get();

                byte[] valueBytes = kvPair.getSecond().getValue();

                if(!keyObject.equals(MetadataVersionStoreUtils.VERSIONS_METADATA_KEY)) {

                    continue;

                }

            } catch(Exception e) {

                System.err.println("Error while retrieving Metadata versions from node : " + nodeId

                                   + ". Exception = \n");

                e.printStackTrace();

                System.exit(-1);

            StorageEngine<ByteArray, byte[], byte[]> engine = storageConfig.getStore(TestUtils.makeStoreDefinition("test"),

                                                                                     TestUtils.makeSingleNodeRoutingStrategy());

            @SuppressWarnings("unchecked")

            final Store<String, byte[], byte[]> store = new SerializingStore(engine,

                                                                             new IdentitySerializer(),

                                                                             null);

            final byte[] value = new byte[valueSize];

            new Random().nextBytes(value);

        target2.put(100, Versioned.value(Arrays.asList(values2)), null);

    }

    public Store<String, String, String> getEngine1(View<?, ?, ?, ?> valTrans) {

        return SerializingStore.wrap(new ViewStorageEngine("test",

                                                           targetRaw1,

                                                           s,

                                                           s,

                                                           s,

        } else {

            store = new BdbStorageEngine(storeName, environment, database, new BdbRuntimeConfig());

        }

        StorageEngine<String, String, String> stringStore = SerializingStorageEngine.wrap(store,

        Iterator<Pair<String, Versioned<String>>> iter = stringStore.entries();

        while(iter.hasNext()) {

            Pair<String, Versioned<String>> entry = iter.next();

            System.out.println(entry.getFirst() + " => " + entry.getSecond().getValue());

        }