Logo Search packages:      
Sourcecode: zeroc-ice-java version File versions  Download package

Client.java

// **********************************************************************
//
// Copyright (c) 2003-2006 ZeroC, Inc. All rights reserved.
//
// This copy of Ice is licensed to you under the terms described in the
// ICE_LICENSE file included in this distribution.
//
// **********************************************************************

import Freeze.*;

public class Client
{
    static class ReadThread extends Thread
    {
        public void
        run()
        { 
            try
            {
            for(int i = 0; i < 10; ++i)
            {
                for(;;)
                {
                  java.util.Iterator p = null;

                  try
                  {
                      java.util.Set entrySet = _map.entrySet();
                      p = entrySet.iterator();
                   
                      while(p.hasNext())
                      {
                        java.util.Map.Entry e = (java.util.Map.Entry)p.next();
                        byte v = ((Byte)e.getKey()).byteValue();
                        test(e.getValue().equals(new Integer(v - (byte)'a')));
                      }
                      break;
                  }
                  catch(DeadlockException ex)
                  {
                      // System.err.print("r");
                      //
                      // Try again
                      //
                  }
                  finally
                  {
                      if(p != null)
                      {
                        ((Freeze.Map.EntryIterator)p).close();
                      }
                  }
                }
            }
          }
          catch(Exception ex)
          {
            ex.printStackTrace();
            System.err.println(ex);
          }
          finally
          {
            ((Freeze.Map) _map).close();
            _connection.close();
          }
      }
      
      ReadThread(Ice.Communicator communicator, String envName, String dbName)
        {
          _connection = Freeze.Util.createConnection(communicator, envName);
          _map = new ByteIntMap(_connection, dbName, true);
      }

      private Freeze.Connection _connection;
      private java.util.Map _map;
    }


    static class WriteThread extends Thread
    {
        public void
        run()
        {
            try
            {
            for(int i = 0; i < 4; ++i)
            {
                for(;;)
                {
                  java.util.Iterator p = null;

                  try
                  {
                      java.util.Set entrySet = _map.entrySet();
                      p = entrySet.iterator();
                   
                      while(p.hasNext())
                      {
                        java.util.Map.Entry e = (java.util.Map.Entry)p.next();
                        int v = ((Integer)e.getValue()).intValue() + 1;
                        e.setValue(new Integer(v));
                        p.remove();
                      }
                      
                      break;
                  }
                  catch(DeadlockException ex)
                  {
                      // System.err.print("w");
                      //
                      // Try again
                      //
                  }
                  finally
                  {
                      if(p != null)
                      {
                        ((Freeze.Map.EntryIterator)p).close();
                      }
                  }
                }
                populateDB(_connection, _map);
            }
          }
          catch(Exception ex)
          {
            ex.printStackTrace();
            System.err.println(ex);
          }
          finally
          {
            ((Freeze.Map)_map).close();
            _connection.close();
          }
      }
      
      WriteThread(Ice.Communicator communicator, String envName, String dbName)
        {
          _connection = Freeze.Util.createConnection(communicator, envName);
          _map = new ByteIntMap(_connection, dbName, true);
      }

      private Freeze.Connection _connection;
      private java.util.Map _map;
    }


    static String alphabet = "abcdefghijklmnopqrstuvwxyz";

    private static void
    test(boolean b)
    {
        if(!b)
        {
            throw new RuntimeException();
        }
    }

    private static void
    populateDB(Freeze.Connection connection, java.util.Map m)
      throws DatabaseException
    {
      int length = alphabet.length();

      for(;;)
      {
         
          try
          {
            Transaction tx = connection.beginTransaction();
            for(int j = 0; j < length; ++j)
            {
                m.put(new Byte((byte)alphabet.charAt(j)), new Integer(j));
            }
            tx.commit();
            break; // for(;;)
          }
          catch(Freeze.DeadlockException dx)
          {
            length = length / 2;
            // System.err.print("t");
            //
            // Try again
            //
          }
          finally
          {
            if(connection.currentTransaction() != null)
            {
                connection.currentTransaction().rollback();
            }
          }
      }
    }

    private static int
    run(String[] args, Ice.Communicator communicator, String envName, String dbName)
      throws DatabaseException
    {
      Freeze.Connection connection = Freeze.Util.createConnection(communicator, envName);

      java.util.Map m = new ByteIntMap(connection, dbName, true);

      //
      // Populate the database with the alphabet.
      //
      populateDB(connection, m);

      int j;

      System.out.print("testing populate... ");
        System.out.flush();
      for(j = 0; j < alphabet.length(); ++j)
      {
          Object value = m.get(new Byte((byte)alphabet.charAt(j)));
          test(value != null);
      }
      test(m.get(new Byte((byte)'0')) == null);
      for(j = 0; j < alphabet.length(); ++j)
      {
          test(m.containsKey(new Byte((byte)alphabet.charAt(j))));
      }
      test(!m.containsKey(new Byte((byte)'0')));
      for(j = 0; j < alphabet.length(); ++j)
      {
          test(m.containsValue(new Integer(j)));
      }
      test(!m.containsValue(new Integer(-1)));
      test(m.size() == alphabet.length());
      test(!m.isEmpty());
      System.out.println("ok");

      System.out.print("testing erase... ");
        System.out.flush();
      m.remove(new Byte((byte)'a'));
      m.remove(new Byte((byte)'b'));
      m.remove(new Byte((byte)'c'));
      for(j = 3; j < alphabet.length(); ++j)
      {
          Object value = m.get(new Byte((byte)alphabet.charAt(j)));
          test(value != null);
      }
      test(m.get(new Byte((byte)'a')) == null);
      test(m.get(new Byte((byte)'b')) == null);
      test(m.get(new Byte((byte)'c')) == null);
      System.out.println("ok");
      
      //
      // Re-populate.
      //
      populateDB(connection, m);

      {
          System.out.print("testing keySet... ");
          System.out.flush();
          java.util.Set keys = m.keySet();
          test(keys.size() == alphabet.length());
          test(!keys.isEmpty());
          java.util.Iterator p = keys.iterator();
          while(p.hasNext())
          {
            Object o = p.next();
            test(keys.contains(o));

            Byte b = (Byte)o;
            test(m.containsKey(b));
          }
          System.out.println("ok");
      }

      {
          System.out.print("testing values... ");
          System.out.flush();
          java.util.Collection values = m.values();
          test(values.size() == alphabet.length());
          test(!values.isEmpty());
          java.util.Iterator p = values.iterator();
          while(p.hasNext())
          {
            Object o = p.next();
            test(values.contains(o));

            Integer i = (Integer)o;
            test(m.containsValue(i));
          }
          System.out.println("ok");
      }

      {
          System.out.print("testing entrySet... ");
          System.out.flush();
          java.util.Set entrySet = m.entrySet();
          test(entrySet.size() == alphabet.length());
          test(!entrySet.isEmpty());
          java.util.Iterator p = entrySet.iterator();
          while(p.hasNext())
          {
            Object o = p.next();
            test(entrySet.contains(o));

            java.util.Map.Entry e = (java.util.Map.Entry)o;
            test(m.containsKey(e.getKey()));
            test(m.containsValue(e.getValue()));
          }
          System.out.println("ok");
      }

      {
          System.out.print("testing iterator.remove... ");
          System.out.flush();

          test(m.size() == 26);
          test(m.get(new Byte((byte)'b')) != null);
          test(m.get(new Byte((byte)'n')) != null);
          test(m.get(new Byte((byte)'z')) != null);

          ((Freeze.Map) m).closeAllIterators();

          java.util.Set entrySet = m.entrySet();
          java.util.Iterator p = entrySet.iterator();
         
          while(p.hasNext())
          {
            java.util.Map.Entry e = (java.util.Map.Entry)p.next();
            Byte b = (Byte)e.getKey();
            byte v = b.byteValue();
            if(v == (byte)'b' || v == (byte)'n' || v == (byte)'z')
            {
                p.remove();
                try
                {
                  p.remove();
                }
                catch(IllegalStateException ex)
                {
                  // Expected.
                }
            }
          }
          ((Freeze.Map) m).closeAllIterators();

          test(m.size() == 23);
          test(m.get(new Byte((byte)'b')) == null);
          test(m.get(new Byte((byte)'n')) == null);
          test(m.get(new Byte((byte)'z')) == null);

          //
          // Re-populate.
          //
          populateDB(connection, m);
          
          test(m.size() == 26);

          entrySet = m.entrySet();
          p = entrySet.iterator();
          while(p.hasNext())
          {
            java.util.Map.Entry e = (java.util.Map.Entry)p.next();
            byte v = ((Byte)e.getKey()).byteValue();
            if(v == (byte)'a' || v == (byte)'b' || v == (byte)'c')
            {
                p.remove();
            }
          }
          ((Freeze.Map) m).closeAllIterators();

          test(m.size() == 23);
          test(m.get(new Byte((byte)'a')) == null);
          test(m.get(new Byte((byte)'b')) == null);
          test(m.get(new Byte((byte)'c')) == null);
          System.out.println("ok");
      }

        {
            System.out.print("testing entry.setValue... ");
            System.out.flush();

            //
            // Re-populate.
            //
            populateDB(connection, m);

            java.util.Set entrySet = m.entrySet();
            java.util.Iterator p = entrySet.iterator();
            while(p.hasNext())
            {
                java.util.Map.Entry e = (java.util.Map.Entry)p.next();
                byte v = ((Byte)e.getKey()).byteValue();
                if(v == (byte)'b' || v == (byte)'n' || v == (byte)'z')
                {
                    e.setValue(new Integer(v + 100));
                }
            }
          ((Freeze.Map) m).closeAllIterators();
            test(m.size() == 26);
            test(m.get(new Byte((byte)'b')) != null);
            test(m.get(new Byte((byte)'n')) != null);
            test(m.get(new Byte((byte)'z')) != null);

            p = entrySet.iterator();
            while(p.hasNext())
            {
                java.util.Map.Entry e = (java.util.Map.Entry)p.next();
                byte v = ((Byte)e.getKey()).byteValue();
                if(v == (byte)'b' || v == (byte)'n' || v == (byte)'z')
                {
                    test(e.getValue().equals(new Integer(v + 100)));
                }
                else
                {
                    test(e.getValue().equals(new Integer(v - (byte)'a')));
                }
            }
            System.out.println("ok");
        }

      {
            System.out.print("testing index... ");
            System.out.flush();

          //
            // Re-populate.
            //
            populateDB(connection, m);

          ByteIntMap typedM = (ByteIntMap)m;

          java.util.Map.Entry e;
          java.util.Iterator p;

          int length = alphabet.length();

          for(int k = 0; k < length; ++k)
          {
            p = typedM.findByValue(k);
            test(p.hasNext());
            e = (java.util.Map.Entry)p.next();
            test(((Byte)e.getKey()).byteValue() == (byte)alphabet.charAt(k));
            test(!p.hasNext());
          }

          //
          // Non-existent index value
          //
          p = typedM.findByValue(100);
          test(!p.hasNext());

          //
          // 2 items at 17
          // 
          m.put(new Byte((byte)alphabet.charAt(21)), new Integer(17));
          
          p = typedM.findByValue(17);
          
          test(p.hasNext());
          e = (java.util.Map.Entry)p.next();
          byte v = ((Byte)e.getKey()).byteValue();
          test(v == (byte)alphabet.charAt(17) || v == (byte)alphabet.charAt(21));
          
          test(p.hasNext());
          e = (java.util.Map.Entry)p.next();
          v = ((Byte)e.getKey()).byteValue();
          test(v == (byte)alphabet.charAt(17) || v == (byte)alphabet.charAt(21));
          
          test(!p.hasNext());
          test(typedM.valueCount(17) == 2);

          p = typedM.findByValue(17);
          test(p.hasNext());
          p.next();
          p.remove();
          test(p.hasNext());
          e = (java.util.Map.Entry)p.next();
          v = ((Byte)e.getKey()).byteValue();
          test(v == (byte)alphabet.charAt(17) || v == (byte)alphabet.charAt(21));
          test(!p.hasNext());

          //
          // We need to close this write iterator before further reads
          //
          typedM.closeAllIterators();

          test(typedM.valueCount(17) == 1);

          p = typedM.findByValue(17);
          test(p.hasNext());
          e = (java.util.Map.Entry)p.next();

          try
          {
            e.setValue(new Integer(18));
            test(false);
          }
          catch(UnsupportedOperationException ex)
          {
            // Expected
          }

          v = ((Byte)e.getKey()).byteValue();
          test(v == (byte)alphabet.charAt(17) || v == (byte)alphabet.charAt(21));
          test(typedM.valueCount(17) == 1);
            System.out.println("ok");
        }


      ((Freeze.Map) m).closeAllIterators();

      {
          System.out.print("testing concurrent access... ");
          System.out.flush();
      
          m.clear();
          populateDB(connection, m);
          

          java.util.List l = new java.util.ArrayList();
      
          //
          // Create each thread.
          //
          for(int i = 0; i < 5; ++i)
          {
            l.add(new ReadThread(communicator, envName, dbName));
            l.add(new WriteThread(communicator, envName, dbName));
          }

          //
          // Start each thread.
          //
          java.util.Iterator p = l.iterator();
          while(p.hasNext())
          {
            Thread thr = (Thread)p.next();
            thr.start();
          }
      
          //
          // Wait for each thread to terminate.
          //
          p = l.iterator();
          while(p.hasNext())
          {
            Thread thr = (Thread)p.next();
            while(thr.isAlive())
            {
                try
                {
                  thr.join();
                }
                catch(InterruptedException e)
                {
                }
            }
          }

          System.out.println("ok");
      }

      System.out.print("testing index creation... ");
      System.out.flush();

      {
          IntIdentityMap iim = new IntIdentityMap(connection, "intIdentity", true);

          Ice.Identity odd = new Ice.Identity();
          odd.name = "foo";
          odd.category = "odd";
          
          Ice.Identity even = new Ice.Identity();
          even.name = "bar";
          even.category = "even";
          
          Transaction tx = connection.beginTransaction();
          for(int i = 0; i < 1000; i++)
          {
            if(i % 2 == 0)
            {
                iim.fastPut(new Integer(i), even);
            }
            else
            {
                iim.fastPut(new Integer(i), odd);
            }
          }
          tx.commit();
          iim.close();
      }
      
      {
          //
          // Need true to create the index
          //
          IntIdentityMapWithIndex iim = new IntIdentityMapWithIndex(connection, "intIdentity", true);
          
          test(iim.categoryCount("even") == 500);
          test(iim.categoryCount("odd") == 500);
          
          int count = 0;
          java.util.Iterator p = iim.findByCategory("even");
          while(p.hasNext())
          {
            java.util.Map.Entry e = (java.util.Map.Entry)p.next();
            int k = ((Integer)e.getKey()).intValue();
            test(k % 2 == 0);
            ++count;
          }
          test(count == 500);

          count = 0;
          p = iim.findByCategory("odd");
          while(p.hasNext())
          {
            java.util.Map.Entry e = (java.util.Map.Entry)p.next();
            int k = ((Integer)e.getKey()).intValue();
            test(k % 2 == 1);
            ++count;
          }
          test(count == 500);
          
          iim.closeAllIterators();
          iim.clear();
      }
      System.out.println("ok");
      
      System.out.print("testing sorting... ");
      System.out.flush();


      final java.util.Comparator less =
          new java.util.Comparator()
          {
            public int compare(Object o1, Object o2)
            {
                if(o1 == o2)
                {
                  return 0;
                }
                else if(o1 == null)
                {
                  return -((Comparable)o2).compareTo(o1);
                }
                else
                {
                  return ((Comparable)o1).compareTo(o2);
                }
            }
          };
      
      java.util.Comparator greater =
          new java.util.Comparator()
          {
            public int compare(Object o1, Object o2)
            {
                return -less.compare(o1, o2);
            }
          };
      
      java.util.Map indexComparators = new java.util.HashMap();
      indexComparators.put("category", greater);
      java.util.Random rand = new java.util.Random();

      {
          SortedMap sm = new SortedMap(connection, "sortedMap", true, less, indexComparators);

          Transaction tx = connection.beginTransaction();
          for(int i = 0; i < 500; i++)
          {
            int k = rand.nextInt(1000); 
            
            Ice.Identity id = new Ice.Identity("foo",
                                       String.valueOf(alphabet.charAt(k % 26)));
                                       
            
            sm.fastPut(new Integer(k), id);
          }
          tx.commit();
          sm.close();
      }

      {
          SortedMap sm = new SortedMap(connection, "sortedMap", true, less, indexComparators);
          
          //
          // Primary key
          //
          for(int i = 0; i < 100; i++)
          {
            int k = rand.nextInt(1000);

            java.util.SortedMap subMap = sm.tailMap(new Integer(k));
            try
            {
                Integer fk = (Integer)subMap.firstKey();
                test(fk.intValue() >= k);
            }
            catch(NoSuchElementException e)
            {
                // Expected from time to time
            }
            
            subMap = sm.headMap(new Integer(k));
            try
            {
                Integer lk = (Integer)subMap.lastKey();
                test(lk.intValue() < k);
            }
            catch(NoSuchElementException e)
            {
                // Expected from time to time
            }
            
            //
            // Now with an iterator
            //
            java.util.Iterator p = subMap.keySet().iterator();
            while(p.hasNext())
            {
                Integer ck = (Integer)p.next();
                test(ck.intValue() < k);
            }
            sm.closeAllIterators();
          }

          //
          // Category index
          //
          for(int i = 0; i < 100; i++)
          {
            int k = rand.nextInt(1000);
            String category = String.valueOf(alphabet.charAt(k % 26));
            
            java.util.SortedMap subMap = sm.tailMapForIndex("category", category);
            try
            {
                String fk = (String)subMap.firstKey();
                test(greater.compare(fk, category) >= 0);
            }
            catch(NoSuchElementException e)
            {
                // Expected from time to time
            }
            
            subMap = sm.headMapForIndex("category", category);
            try
            {
                String lk = (String)subMap.lastKey();
                test(greater.compare(lk, category) < 0);
            }
            catch(NoSuchElementException e)
            {
                // Expected from time to time
            }

            //
            // Now with an iterator
            //
            java.util.Iterator p = subMap.keySet().iterator();
            while(p.hasNext())
            {
                String ck = (String)p.next();
                test(greater.compare(ck, category) < 0);
            }
            sm.closeAllIterators();
          }
          
          java.util.SortedMap subMap = sm.mapForIndex("category");
          java.util.Iterator p = subMap.entrySet().iterator();
          String category = null;

          while(p.hasNext())
          {
            java.util.Map.Entry entry = (java.util.Map.Entry)p.next();
            
            if(category != null)
            {
                test(greater.compare(category, entry.getKey()) < 0);
            }
            category = (String)entry.getKey();
            // System.out.println("*******Category == " + category);

            
            java.util.Iterator q = ((java.util.Set)entry.getValue()).iterator();
            while(q.hasNext())
            {
                //
                // All my map entries
                //
                entry = (java.util.Map.Entry)q.next();
                Ice.Identity id = (Ice.Identity)entry.getValue();
                test(category.equals(id.category));
                
                // System.out.println("Key == " + entry.getKey().toString());

            }
          }
          sm.closeAllIterators();
          sm.clear();
          sm.close();
      }
      System.out.println("ok");
      connection.close();
      
      return 0;
    }

    static public void
    main(String[] args)
    {
      int status;
      Ice.Communicator communicator = null;
      String envName = "db";
      
      try
      {
          Ice.StringSeqHolder holder = new Ice.StringSeqHolder();
          holder.value = args;
          communicator = Ice.Util.initialize(holder);
          args = holder.value;
          if(args.length > 0)
          {
            envName = args[0];
            envName += "/";
            envName += "db";
          }
          
          status = run(args, communicator, envName, "binary");
      }
      catch(Exception ex)
      {
          ex.printStackTrace();
          status = 1;
      }

      if(communicator != null)
      {
          try
          {
            communicator.destroy();
          }
          catch(Exception ex)
          {
            System.err.println(ex);
            status = 1;
          }
      }

      System.gc();
      System.exit(status);
    }
}

Generated by  Doxygen 1.6.0   Back to index