@Test
 public void valuesToArray() {
   HazelcastClient hClient = getHazelcastClient();
   IMap map = hClient.getMap("valuesToArray");
   assertEquals(0, map.size());
   map.put("a", "1");
   map.put("b", "2");
   map.put("c", "3");
   assertEquals(3, map.size());
   {
     final Object[] values = map.values().toArray();
     Arrays.sort(values);
     assertArrayEquals(new Object[] {"1", "2", "3"}, values);
   }
   {
     final String[] values = (String[]) map.values().toArray(new String[3]);
     Arrays.sort(values);
     assertArrayEquals(new String[] {"1", "2", "3"}, values);
   }
   {
     final String[] values = (String[]) map.values().toArray(new String[2]);
     Arrays.sort(values);
     assertArrayEquals(new String[] {"1", "2", "3"}, values);
   }
   {
     final String[] values = (String[]) map.values().toArray(new String[5]);
     Arrays.sort(values, 0, 3);
     assertArrayEquals(new String[] {"1", "2", "3", null, null}, values);
   }
 }
コード例 #2
0
  /** @return Client configuration for the test. */
  protected GridClientConfiguration clientConfiguration() throws GridClientException {
    GridClientConfiguration cfg = new GridClientConfiguration();

    cfg.setBalancer(getBalancer());

    cfg.setTopologyRefreshFrequency(TOP_REFRESH_FREQ);

    cfg.setProtocol(protocol());
    cfg.setServers(Arrays.asList(serverAddress()));
    cfg.setSslContextFactory(sslContextFactory());

    GridClientDataConfiguration loc = new GridClientDataConfiguration();

    GridClientDataConfiguration partitioned = new GridClientDataConfiguration();

    partitioned.setName(PARTITIONED_CACHE_NAME);
    partitioned.setAffinity(new GridClientPartitionAffinity());

    GridClientDataConfiguration replicated = new GridClientDataConfiguration();
    replicated.setName(REPLICATED_CACHE_NAME);

    GridClientDataConfiguration replicatedAsync = new GridClientDataConfiguration();
    replicatedAsync.setName(REPLICATED_ASYNC_CACHE_NAME);

    cfg.setDataConfigurations(Arrays.asList(loc, partitioned, replicated, replicatedAsync));

    return cfg;
  }
コード例 #3
0
  /**
   * Copy from the copy method in StructUtil. Did not want to drag that code in. maybe this actually
   * should go to struct.
   *
   * @param from
   * @param to
   * @param excludes
   * @return
   * @throws Exception
   */
  public static <T extends struct> T xcopy(struct from, T to, String... excludes) throws Exception {
    Arrays.sort(excludes);
    for (Field f : from.fields()) {
      if (Arrays.binarySearch(excludes, f.getName()) >= 0) continue;

      Object o = f.get(from);
      if (o == null) continue;

      Field tof = to.getField(f.getName());
      if (tof != null)
        try {
          tof.set(to, Converter.cnv(tof.getGenericType(), o));
        } catch (Exception e) {
          System.out.println(
              "Failed to convert "
                  + f.getName()
                  + " from "
                  + from.getClass()
                  + " to "
                  + to.getClass()
                  + " value "
                  + o
                  + " exception "
                  + e);
        }
    }

    return to;
  }
コード例 #4
0
 /** descendingkeySet.toArray returns contains all keys */
 public void testDescendingDescendingKeySetToArray() {
   ConcurrentNavigableMap map = dmap5();
   Set s = map.descendingKeySet();
   Object[] ar = s.toArray();
   assertEquals(5, ar.length);
   assertTrue(s.containsAll(Arrays.asList(ar)));
   ar[0] = m10;
   assertFalse(s.containsAll(Arrays.asList(ar)));
 }
  @Test
  public void testDelayErrorMaxConcurrent() {
    final List<Long> requests = new ArrayList<>();
    Observable<Integer> source =
        Observable.mergeDelayError(
            Observable.just(
                    Observable.just(1).asObservable(),
                    Observable.<Integer>error(new TestException()))
                .doOnRequest(
                    new LongConsumer() {
                      @Override
                      public void accept(long t1) {
                        requests.add(t1);
                      }
                    }),
            1);

    TestSubscriber<Integer> ts = new TestSubscriber<>();

    source.subscribe(ts);

    ts.assertValue(1);
    ts.assertTerminated();
    ts.assertError(TestException.class);
    assertEquals(Arrays.asList(1L, 1L, 1L), requests);
  }
コード例 #6
0
  /** @throws Exception If failed. */
  public void testClientAffinity() throws Exception {
    GridClientData partitioned = client.data(PARTITIONED_CACHE_NAME);

    Collection<Object> keys = new ArrayList<>();

    keys.addAll(Arrays.asList(Boolean.TRUE, Boolean.FALSE, 1, Integer.MAX_VALUE));

    Random rnd = new Random();
    StringBuilder sb = new StringBuilder();

    // Generate some random strings.
    for (int i = 0; i < 100; i++) {
      sb.setLength(0);

      for (int j = 0; j < 255; j++)
        // Only printable ASCII symbols for test.
        sb.append((char) (rnd.nextInt(0x7f - 0x20) + 0x20));

      keys.add(sb.toString());
    }

    // Generate some more keys to achieve better coverage.
    for (int i = 0; i < 100; i++) keys.add(UUID.randomUUID());

    for (Object key : keys) {
      UUID nodeId = grid(0).mapKeyToNode(PARTITIONED_CACHE_NAME, key).id();

      UUID clientNodeId = partitioned.affinity(key);

      assertEquals(
          "Invalid affinity mapping for REST response for key: " + key, nodeId, clientNodeId);
    }
  }
コード例 #7
0
ファイル: PooledFatPipe.java プロジェクト: ioworks/fat-pipe
 private void add(PooledFatPipe child) {
   long start = System.currentTimeMillis();
   while (true) {
     int fails = 0;
     for (int i = 0; i < inUse.length(); i++) {
       if (!inUse.compareAndSet(i, 0, 2)) {
         if (inUse.get(i) != 2) fails++;
       }
     }
     if (fails == 0) break;
     if (start + 100 < System.currentTimeMillis()) {
       logger.warn("unable to add cleanly " + toString());
       break;
     }
   }
   final AtomicIntegerArray updated = new AtomicIntegerArray(inUse.length() + 1);
   final List<Integer> needsReset = new ArrayList<>();
   for (int i = 0; i < inUse.length(); i++) {
     int value = inUse.get(i);
     if (value == 1) {
       updated.set(i, value);
       needsReset.add(i);
     }
   }
   final AtomicIntegerArray oldUse = inUse;
   inUse = updated;
   signals = new ChildSignalImpl[signals.length + poolSize];
   for (int i = 0; i < signals.length; i++) {
     signals[i] = new ChildSignalImpl(inUse, 0);
   }
   children = Arrays.copyOf(children, children.length + 1);
   children[children.length - 1] = child;
   scheduleReset(needsReset, oldUse, updated);
 }
コード例 #8
0
  /**
   * Prints a phrase on the grid nodes running anonymous closure objects and calculating total
   * number of letters.
   *
   * @param phrase Phrase to print on of the grid nodes.
   * @throws GridException If failed.
   */
  private static void countLettersClosure(String phrase) throws GridException {
    X.println(">>> Starting countLettersClosure() example...");

    // Explicitly execute the collection of callable objects and receive a result.
    Collection<Integer> results =
        G.grid()
            .call(
                SPREAD,
                new GridClosure<String, Integer>() { // Create executable logic.
                  @Override
                  public Integer apply(String word) {
                    // Print out a given word, just so we can
                    // see which node is doing what.
                    X.println(">>> Executing word: " + word);

                    // Return the length of a given word, i.e. number of letters.
                    return word.length();
                  }
                },
                Arrays.asList(phrase.split(" "))); // Collection of arguments for closures.

    // Add up all results using convenience 'sum()' method.
    int letterCnt = F.sum(results);

    X.println(">>>");
    X.println(">>> Finished execution of counting letters with closure based on GridGain 3.0 API.");
    X.println(">>> You should see the phrase '" + phrase + "' printed out on the nodes.");
    X.println(">>> Total number of letters in the phrase is '" + letterCnt + "'.");
    X.println(">>> Check all nodes for output (this node is also part of the grid).");
    X.println(">>>");
  }
コード例 #9
0
  @Test
  public void testOnStartRequestsAreAdditiveAndOverflowBecomesMaxValue() {
    final List<Integer> list = new ArrayList<>();
    Observable.just(1, 2, 3, 4, 5)
        .subscribe(
            new Observer<Integer>() {
              @Override
              public void onStart() {
                request(2);
                request(Long.MAX_VALUE - 1);
              }

              @Override
              public void onComplete() {}

              @Override
              public void onError(Throwable e) {}

              @Override
              public void onNext(Integer t) {
                list.add(t);
              }
            });
    assertEquals(Arrays.asList(1, 2, 3, 4, 5), list);
  }
コード例 #10
0
 /** addAll of a collection with null elements throws NPE */
 public void testAddAll2() {
   try {
     Succeed q = new Succeed();
     Integer[] ints = new Integer[SIZE];
     q.addAll(Arrays.asList(ints));
     shouldThrow();
   } catch (NullPointerException success) {
   }
 }
コード例 #11
0
ファイル: HotPotatoes.java プロジェクト: nbronson/snaptree
  private static void testImplementation(Class<? extends Collection> implClazz) throws Throwable {
    testPotato(implClazz, Vector.class);
    testPotato(implClazz, CopyOnWriteArrayList.class);

    final Constructor<? extends Collection> constr = implClazz.getConstructor(Collection.class);
    final Collection<Object> coll = constr.newInstance(Arrays.asList(new String[] {}));
    coll.add(1);
    equal(coll.toString(), "[1]");
  }
コード例 #12
0
ファイル: RegularBot.java プロジェクト: hugepython52/DarkBot
 public RegularBot(RegularBotControlsUI ui, RegularBotData data) {
   this.ui = ui;
   data.lock();
   this.data = data;
   commands = new ArrayList<Command>();
   commands.addAll(Arrays.asList((Command[]) DefaultCommands.values()));
   status("Waiting.");
   progress(0, false);
   connect();
 }
コード例 #13
0
 /**
  * addAll of a collection with any null elements throws NPE after possibly adding some elements
  */
 public void testAddAll3() {
   try {
     Succeed q = new Succeed();
     Integer[] ints = new Integer[SIZE];
     for (int i = 0; i < SIZE - 1; ++i) ints[i] = new Integer(i);
     q.addAll(Arrays.asList(ints));
     shouldThrow();
   } catch (NullPointerException success) {
   }
 }
コード例 #14
0
 /** addAll throws ISE if an add fails */
 public void testAddAll4() {
   try {
     Fail q = new Fail();
     Integer[] ints = new Integer[SIZE];
     for (int i = 0; i < SIZE; ++i) ints[i] = new Integer(i);
     q.addAll(Arrays.asList(ints));
     shouldThrow();
   } catch (IllegalStateException success) {
   }
 }
コード例 #15
0
ファイル: GridSearch.java プロジェクト: hhyifeng/algorithm
 /**
  * Adds a new int parameter to be altered for the model being tuned.
  *
  * @param param the model parameter
  * @param initialSearchValues the values to try for the specified parameter
  */
 public void addParameter(IntParameter param, int... initialSearchValues) {
   searchParams.add(param);
   DoubleList dl = new DoubleList(initialSearchValues.length);
   for (double d : initialSearchValues) dl.add(d);
   Arrays.sort(dl.getBackingArray()); // convience, only really needed if param is warm
   if (param.isWarmParameter() && !param.preferredLowToHigh())
     Collections.reverse(dl); // put it in the prefered order
   if (param.isWarmParameter()) // put it at the front!
   searchValues.add(0, dl);
   else searchValues.add(dl);
 }
コード例 #16
0
ファイル: GridSearch.java プロジェクト: hhyifeng/algorithm
 /**
  * Adds a new double parameter to be altered for the model being tuned.
  *
  * @param param the model parameter
  * @param initialSearchValues the values to try for the specified parameter
  */
 public void addParameter(DoubleParameter param, double... initialSearchValues) {
   if (param == null) throw new IllegalArgumentException("null not allowed for parameter");
   searchParams.add(param);
   DoubleList dl = new DoubleList(initialSearchValues.length);
   for (double d : initialSearchValues) dl.add(d);
   Arrays.sort(dl.getBackingArray()); // convience, only really needed if param is warm
   if (param.isWarmParameter() && !param.preferredLowToHigh())
     Collections.reverse(dl); // put it in the prefered order
   if (param.isWarmParameter()) // put it at the front!
   searchValues.add(0, dl);
   else searchValues.add(dl);
 }
コード例 #17
0
 /** Values.toArray contains all values */
 public void testDescendingValuesToArray() {
   ConcurrentNavigableMap map = dmap5();
   Collection v = map.values();
   Object[] ar = v.toArray();
   ArrayList s = new ArrayList(Arrays.asList(ar));
   assertEquals(5, ar.length);
   assertTrue(s.contains("A"));
   assertTrue(s.contains("B"));
   assertTrue(s.contains("C"));
   assertTrue(s.contains("D"));
   assertTrue(s.contains("E"));
 }
コード例 #18
0
  /**
   * Calculates length of a given phrase on the grid.
   *
   * @param phrase Phrase to count the number of letters in.
   * @throws GridException If failed.
   */
  private static void countLettersReducer(String phrase) throws GridException {
    X.println(">>> Starting countLettersReducer() example...");

    Grid grid = G.grid();

    // Logger to use in your closure. Note that even though we assign it
    // to a local variable, GridGain still allows to use it from remotely
    // executed code.
    final GridLogger log = grid.log();

    // Execute Hello World task.
    int letterCnt =
        grid.reduce(
            BALANCE,
            new GridClosure<String, Integer>() { // Create executable logic.
              @Override
              public Integer apply(String word) {
                // Print out a given word, just so we can
                // see which node is doing what.
                log.info(">>> Calculating for word: " + word);

                // Return the length of a given word, i.e. number of letters.
                return word.length();
              }
            },
            Arrays.asList(phrase.split(" ")), // Collection of words.
            // Create custom reducer.
            // NOTE: Alternatively, you can use existing reducer: F.sumIntReducer()
            new GridReducer<Integer, Integer>() {
              private int sum;

              @Override
              public boolean collect(Integer res) {
                sum += res;

                return true; // True means continue collecting until last result.
              }

              @Override
              public Integer apply() {
                return sum;
              }
            });

    X.println(">>>");
    X.println(">>> Finished execution of counting letters with reducer based on GridGain 3.0 API.");
    X.println(">>> Total number of letters in the phrase is '" + letterCnt + "'.");
    X.println(">>> You should see individual words printed out on different nodes.");
    X.println(">>> Check all nodes for output (this node is also part of the grid).");
    X.println(">>>");
  }
コード例 #19
0
 @Test
 public void putBigObject() {
   HazelcastClient hClient = getHazelcastClient();
   Map<String, Object> clientMap = hClient.getMap("putABigObject");
   List list = new ArrayList();
   int size = 10000000;
   byte[] b = new byte[size];
   b[size - 1] = (byte) 144;
   list.add(b);
   clientMap.put("obj", b);
   byte[] bigB = (byte[]) clientMap.get("obj");
   assertTrue(Arrays.equals(b, bigB));
   assertEquals(size, bigB.length);
 }
コード例 #20
0
  /**
   * Returns compact class host.
   *
   * @param obj Object to compact.
   * @return String.
   */
  @Nullable
  public static Object compactObject(Object obj) {
    if (obj == null) return null;

    if (obj instanceof Enum) return obj.toString();

    if (obj instanceof String || obj instanceof Boolean || obj instanceof Number) return obj;

    if (obj instanceof Collection) {
      Collection col = (Collection) obj;

      Object[] res = new Object[col.size()];

      int i = 0;

      for (Object elm : col) res[i++] = compactObject(elm);

      return res;
    }

    if (obj.getClass().isArray()) {
      Class<?> arrType = obj.getClass().getComponentType();

      if (arrType.isPrimitive()) {
        if (obj instanceof boolean[]) return Arrays.toString((boolean[]) obj);
        if (obj instanceof byte[]) return Arrays.toString((byte[]) obj);
        if (obj instanceof short[]) return Arrays.toString((short[]) obj);
        if (obj instanceof int[]) return Arrays.toString((int[]) obj);
        if (obj instanceof long[]) return Arrays.toString((long[]) obj);
        if (obj instanceof float[]) return Arrays.toString((float[]) obj);
        if (obj instanceof double[]) return Arrays.toString((double[]) obj);
      }

      Object[] arr = (Object[]) obj;

      int iMax = arr.length - 1;

      StringBuilder sb = new StringBuilder("[");

      for (int i = 0; i <= iMax; i++) {
        sb.append(compactObject(arr[i]));

        if (i != iMax) sb.append(", ");
      }

      sb.append("]");

      return sb.toString();
    }

    return U.compact(obj.getClass().getName());
  }
コード例 #21
0
  /**
   * Create the containers.
   *
   * @param optionList
   * @return
   */
  public Set<Container> build(Collection<CreateContainerOptions> optionList) {
    Set<Container> containers = new HashSet<Container>();
    FabricService fabricService = getOsgiService(FabricService.class);
    CompletionService<Set<Container>> completionService =
        new ExecutorCompletionService<Set<Container>>(executorService);

    int tasks = 0;
    for (CreateContainerOptions options : optionList) {
      if (!options.isEnsembleServer()) {
        options.setZookeeperUrl(fabricService.getZookeeperUrl());
        completionService.submit(new CreateContainerTask(fabricService, options));
        tasks++;
      }
    }

    try {
      for (int i = 0; i < tasks; i++) {
        Future<Set<Container>> futureContainerSet =
            completionService.poll(CREATE_TIMEOUT, TimeUnit.MILLISECONDS);
        Set<Container> containerSet = futureContainerSet.get();
        CONTAINERS.addAll(containerSet);
        containers.addAll(containerSet);
      }

      for (Container container : containers) {
        Version version = fabricService.getDefaultVersion();
        container.setVersion(version);
        Set<Profile> profiles = new HashSet(Arrays.asList(container.getProfiles()));
        for (String profileName : profileNames) {
          Profile profile = container.getVersion().getProfile(profileName);
          profiles.add(profile);
        }
        container.setProfiles(profiles.toArray(new Profile[profiles.size()]));
      }
      try {
        if (waitForProvisioning) {
          Provision.waitForContainerStatus(containers, provisionTimeOut);
        }
        if (assertProvisioningResult) {
          Provision.assertSuccess(containers, provisionTimeOut);
        }
      } catch (Exception e) {
        throw new FabricException(e);
      }
    } catch (Exception e) {
      throw new FabricException(e);
    }
    return containers;
  }
コード例 #22
0
  private int compare(Revision a, Revision b) {
    if (Arrays.equals(a._id, b._id)) return 0;

    Version va = getVersion(a);
    Version vb = getVersion(b);
    int n = va.compareTo(vb);
    if (n != 0) return n;

    if (a.created != b.created) return a.created > b.created ? 1 : -1;

    for (int i = 0; i < a._id.length; i++)
      if (a._id[i] != b._id[i]) return a._id[i] > b._id[i] ? 1 : -1;

    return 0;
  }
コード例 #23
0
 private static Collection<String> parseSoapResponseForUrls(byte[] data)
     throws SOAPException, IOException {
   // System.out.println(new String(data));
   final Collection<String> urls = new ArrayList<>();
   MessageFactory factory = MessageFactory.newInstance(WS_DISCOVERY_SOAP_VERSION);
   final MimeHeaders headers = new MimeHeaders();
   headers.addHeader("Content-type", WS_DISCOVERY_CONTENT_TYPE);
   SOAPMessage message = factory.createMessage(headers, new ByteArrayInputStream(data));
   SOAPBody body = message.getSOAPBody();
   for (Node node : getNodeMatching(body, ".*:XAddrs")) {
     if (node.getTextContent().length() > 0) {
       urls.addAll(Arrays.asList(node.getTextContent().split(" ")));
     }
   }
   return urls;
 }
コード例 #24
0
  /**
   * Concat arrays in one.
   *
   * @param arrays Arrays.
   * @return Summary array.
   */
  public static int[] concat(int[]... arrays) {
    assert arrays != null;
    assert arrays.length > 1;

    int len = 0;

    for (int[] a : arrays) len += a.length;

    int[] r = Arrays.copyOf(arrays[0], len);

    for (int i = 1, shift = 0; i < arrays.length; i++) {
      shift += arrays[i - 1].length;
      System.arraycopy(arrays[i], 0, r, shift, arrays[i].length);
    }

    return r;
  }
コード例 #25
0
  public void testDelayedTasksReusePooledThreadIfExecuteAtDifferentTimes()
      throws InterruptedException, ExecutionException {
    final AppScheduledExecutorService service = new AppScheduledExecutorService(getName());
    final List<LogInfo> log = Collections.synchronizedList(new ArrayList<>());
    // pre-start one thread
    Future<?> future = service.submit(EmptyRunnable.getInstance());
    future.get();
    service.setBackendPoolCorePoolSize(1);
    assertEquals(1, service.getBackendPoolExecutorSize());

    int delay = 500;

    ScheduledFuture<?> f1 =
        service.schedule((Runnable) () -> log.add(new LogInfo(1)), delay, TimeUnit.MILLISECONDS);
    ScheduledFuture<?> f2 =
        service.schedule(
            (Runnable) () -> log.add(new LogInfo(2)), delay + 100, TimeUnit.MILLISECONDS);
    ScheduledFuture<?> f3 =
        service.schedule(
            (Runnable) () -> log.add(new LogInfo(3)), delay + 200, TimeUnit.MILLISECONDS);

    assertEquals(1, service.getBackendPoolExecutorSize());

    assertFalse(f1.isDone());
    assertFalse(f2.isDone());
    assertFalse(f3.isDone());

    TimeoutUtil.sleep(delay + 200 + 300);
    assertTrue(f1.isDone());
    assertTrue(f2.isDone());
    assertTrue(f3.isDone());
    assertEquals(1, service.getBackendPoolExecutorSize());

    assertEquals(3, log.size());
    Set<Thread> usedThreads =
        new HashSet<>(
            Arrays.asList(
                log.get(0).currentThread, log.get(1).currentThread, log.get(2).currentThread));
    if (usedThreads.size() != 1) {
      System.err.println(ThreadDumper.dumpThreadsToString());
    }
    assertEquals(usedThreads.toString(), 1, usedThreads.size()); // must be executed in same thread

    service.shutdownAppScheduledExecutorService();
    assertTrue(service.awaitTermination(10, TimeUnit.SECONDS));
  }
コード例 #26
0
 public void run() {
   Comparator<Double> comp =
       new Comparator<Double>() {
         public int compare(Double i1, Double i2) {
           component.setValues(values, i1, i2);
           try {
             if (run) Thread.sleep(DELAY);
             else gate.acquire();
           } catch (InterruptedException exception) {
             Thread.currentThread().interrupt();
           }
           return i1.compareTo(i2);
         }
       };
   Arrays.sort(values, comp);
   component.setValues(values, null, null);
 }
コード例 #27
0
  void discoverThread() {

    try {
      this.startupLatch.await();
    } catch (final InterruptedException e) {
      e.printStackTrace();
      return;
    }

    // Increase counter
    this.discoverThreadCounter.incrementAndGet();

    // Create empty data.
    ServiceInfo[] infos = {};

    // Magic: Get all network services of our type.
    try {
      this.jmdnsLock.lock();
      // TODO: jmdsn can be null if no network card is present
      infos = this.jmdns.list(TYPE);
    } catch (final IllegalStateException e) {
      this.logger.status("discoverthread/exception", "message", e.getMessage());
    } finally {
      this.jmdnsLock.unlock();
    }

    // Reset all service infos
    try {
      this.serviceInfosLock.lock();
      this.serviceInfos.clear();
      this.serviceInfos.addAll(Arrays.asList(infos));

    } finally {
      this.serviceInfosLock.unlock();
    }

    // Process all callbacks.
    @SuppressWarnings("unused")
    final Collection<CallbackRequest> toRemove = new ArrayList<CallbackRequest>();

    //
    // TODO: This callback handling needs improvement. Check for unsynchronized access to the
    // allRequest structure
    //
  }
コード例 #28
0
  public DLDFSolver(
      int[] s, int[] learning_startfactors, boolean singleThreaded, boolean useBacktracking) {
    log_info("Heuristic weights: %s", Arrays.deepToString(choicefactors));
    log_info("Reported number of processors: %d", Runtime.getRuntime().availableProcessors());
    nThreads = (singleThreaded || THREAD_COUNT == 1) ? 1 : THREAD_COUNT;
    log_info("No. of threads to be used: %d\n", nThreads);
    this.useBacktracking = useBacktracking;
    log_info("Use backtracking?: %s", useBacktracking ? "Yes" : "No");

    this.tileSequence = new int[s.length];
    System.arraycopy(s, 0, this.tileSequence, 0, s.length);

    if (learning_startfactors != null) {
      if (learning_startfactors.length != learning_starts.length) {
        throw new IllegalArgumentException("Invalid learning factor size");
      }
      System.arraycopy(learning_startfactors, 0, learning_starts, 0, learning_starts.length);
    }
  }
コード例 #29
0
ファイル: ObservableTests.java プロジェクト: spoon-bot/RxJava
  @Test
  public void testStartWithWithScheduler() {
    TestScheduler scheduler = new TestScheduler();
    Observable<Integer> observable =
        Observable.just(3, 4).startWith(Arrays.asList(1, 2)).subscribeOn(scheduler);

    Subscriber<Integer> observer = TestHelper.mockSubscriber();

    observable.subscribe(observer);

    scheduler.advanceTimeBy(1, TimeUnit.MILLISECONDS);

    InOrder inOrder = inOrder(observer);
    inOrder.verify(observer, times(1)).onNext(1);
    inOrder.verify(observer, times(1)).onNext(2);
    inOrder.verify(observer, times(1)).onNext(3);
    inOrder.verify(observer, times(1)).onNext(4);
    inOrder.verify(observer, times(1)).onComplete();
    inOrder.verifyNoMoreInteractions();
  }
コード例 #30
0
ファイル: Session.java プロジェクト: ptolemeza/java-driver
  /**
   * Executes the provided query asynchronously.
   *
   * <p>This method does not block. It returns as soon as the query has been passed to the
   * underlying network stack. In particular, returning from this method does not guarantee that the
   * query is valid or has even been submitted to a live node. Any exception pertaining to the
   * failure of the query will be thrown when accessing the {@link ResultSetFuture}.
   *
   * <p>Note that for queries that doesn't return a result (INSERT, UPDATE and DELETE), you will
   * need to access the ResultSetFuture (that is call one of its get method to make sure the query
   * was successful.
   *
   * @param query the CQL query to execute (that can be either a {@code Statement} or a {@code
   *     BoundStatement}). If it is a {@code BoundStatement}, all variables must have been bound
   *     (the statement must be ready).
   * @return a future on the result of the query.
   * @throws IllegalStateException if {@code query} is a {@code BoundStatement} but {@code
   *     !query.isReady()}.
   */
  public ResultSetFuture executeAsync(Query query) {

    if (query instanceof Statement) {
      return manager.executeQuery(
          new QueryMessage(
              ((Statement) query).getQueryString(),
              ConsistencyLevel.toCassandraCL(query.getConsistencyLevel())),
          query);
    } else {
      assert query instanceof BoundStatement : query;

      BoundStatement bs = (BoundStatement) query;
      return manager.executeQuery(
          new ExecuteMessage(
              bs.statement.id,
              Arrays.asList(bs.values),
              ConsistencyLevel.toCassandraCL(query.getConsistencyLevel())),
          query);
    }
  }