public void testOnSizeExceeded() throws Exception {
    renderView("/queue-size.xhtml");

    for (int i = 0; i <= 3; i++) {
      clickOnTime(i, "form:button" + i);
    }

    TestsResult result = getTestsResult();
    List<RequestData> dataList = result.getDataList();

    assertEquals(2, dataList.size());

    // dropNext is default
    checkRequestData(dataList.get(0), "form:button0", 0, DEFAULT_REQUEST_TIME, false);
    checkRequestData(
        dataList.get(1), "form:button3", DEFAULT_REQUEST_TIME, DEFAULT_REQUEST_TIME * 2, false);

    NativeArray handlersData = (NativeArray) executeJavaScript("defaultExceededQueueResults");

    assertEquals(2, handlersData.getLength());

    ScriptableObject firstHandlerData = (ScriptableObject) handlersData.get(0, handlersData);
    Double firstEventTime = (Double) firstHandlerData.get("_time", firstHandlerData);

    assertEquals(2d, firstEventTime);

    ScriptableObject secondHandlerData = (ScriptableObject) handlersData.get(1, handlersData);
    Double secondEventTime = (Double) secondHandlerData.get("_time", secondHandlerData);

    assertEquals(3d, secondEventTime);
  }
  public JavascriptArrayFileNameProvider(
      FileProvider fileProvider, String sourceFile, String variableName) throws IOException {

    BufferedReader source = fileProvider.getResource(sourceFile);
    try {
      Context cx = Context.enter();
      Scriptable scope = cx.initStandardObjects();
      cx.evaluateReader(scope, source, sourceFile, 1, null);
      Object x = scope.get(variableName, scope);

      if (!(x instanceof NativeArray)) {
        throw new RuntimeException(
            "Could not find array called " + variableName + " in source file " + sourceFile);
      }
      NativeArray array = (NativeArray) x;
      for (int i = 0; i < array.getLength(); i++) {
        Object o = array.get(i, null);
        if (!(o instanceof String)) {
          throw new RuntimeException(
              "Array contained objects which are not Strings, cannot continue");
        }
        fileNames.add("/" + o);
      }
    } finally {
      Context.exit();
    }
  }
  public void bsync(NativeObject jsRWB) {
    Map<String, Object> jRWB = (Map) Context.jsToJava(jsRWB, Map.class);

    RWBStatement stmt = RWBStatement.make();
    Object req = jRWB.get("request");
    if (req != null) {
      if (req instanceof BEvent) {
        stmt = stmt.request((BEvent) req);
      } else if (req instanceof NativeArray) {
        NativeArray arr = (NativeArray) req;
        stmt =
            stmt.request(
                Arrays.asList(arr.getIndexIds())
                    .stream()
                    .map(i -> (BEvent) arr.get(i))
                    .collect(toSet()));
      }
    }

    stmt =
        stmt.waitFor(convertToEventSet(jRWB.get("waitFor")))
            .block(convertToEventSet(jRWB.get("block")))
            .breakUpon(convertToEventSet(jRWB.get("breakUpon")));

    bthread.bsync(stmt);
  }
Example #4
0
 /**
  * 将Native对象转换为String数组 @Title: toStringArray @Description: TODO(这里用一句话描述这个方法的作用)
  *
  * @param 参数
  * @return String[] 返回类型
  * @throws
  */
 public static String[] toStringArray(NativeArray nv) {
   String[] result = new String[(int) nv.getLength()];
   for (int i = 0; i < result.length; i++) {
     result[i] = StringUtils.toString(nv.get(i, null));
   }
   return result;
 }
Example #5
0
 private static Object[] convertArray(NativeArray jsArray, Map<Object, Boolean> identities) {
   Object[] ids = jsArray.getIds();
   Object[] result = new Object[ids.length];
   for (int i = 0; i < ids.length; i++) {
     Object id = ids[i];
     int index = (Integer) id;
     Object jsValue = jsArray.get(index, jsArray);
     result[i] = jsToJava(jsValue, identities);
   }
   return result;
 }
Example #6
0
 /**
  * 将NativeArray返回结果转换为int[]对象 @Title: toIntArray @Description: TODO(这里用一句话描述这个方法的作用)
  *
  * @param 参数
  * @return int[] 返回类型
  * @throws
  */
 public static int[] toIntArray(NativeArray nv) {
   int[] result = new int[(int) nv.getLength()];
   for (int i = 0; i < result.length; i++) {
     Object obj = nv.get(i, null);
     if (obj instanceof Number) {
       result[i] = ((Number) obj).intValue();
     } else {
       result[i] = StringUtils.toInt(StringUtils.toString(obj), 0);
     }
   }
   return result;
 }
  private EventSet convertToEventSet(Object jsObject) {
    if (jsObject == null) return Events.emptySet;

    // This covers event sets AND events.
    if (jsObject instanceof EventSet) {
      return (EventSet) jsObject;

    } else if (jsObject instanceof NativeArray) {
      NativeArray arr = (NativeArray) jsObject;
      if (Stream.of(arr.getIds()).anyMatch(id -> arr.get(id) == null)) {
        throw new RuntimeException("EventSet Array contains null sets.");
      }
      return ComposableEventSet.anyOf(
          Arrays.asList(arr.getIndexIds())
              .stream()
              .map(i -> (EventSet) arr.get(i))
              .collect(toSet()));
    } else {
      final String errorMessage =
          "Cannot convert " + jsObject + " of class " + jsObject.getClass() + " to an event set";
      Logger.getLogger(BThread.class.getName()).log(Level.SEVERE, errorMessage);
      throw new IllegalArgumentException(errorMessage);
    }
  }
  public void testSingleSizedQueueIgnoreDupResponses() throws Exception {
    renderView("/queue-size.xhtml");

    ParametersBuilder parametersBuilder =
        createAjaxParameters().eventsQueue("singleSizedDefaultQueue").requestDelay(0);

    ajax(0, "a", parametersBuilder);
    ajax(500, "b", parametersBuilder);

    TestsResult result = getTestsResult();
    List<RequestData> list = result.getDataList();

    assertEquals(1, list.size());
    checkRequestData(list.get(0), "a", 0, DEFAULT_REQUEST_TIME, false);

    NativeArray handlersData = (NativeArray) executeJavaScript("defaultSingleSizedQueueResults");

    assertEquals(1, handlersData.getLength());
    assertEquals("a", handlersData.get(0, handlersData));
  }
Example #9
0
  public Document[] map(final String docid, final String doc) {
    context.putThreadLocal("docid", docid);
    Object ret = systemFun.call(context, scope, null, new Object[] {doc, userFun});
    if (ret == null || ret instanceof Undefined) {
      return new Document[] {};
    } else if (ret instanceof RhinoDocument) {
      return new Document[] {((RhinoDocument) ret).doc};
    } else if (ret instanceof NativeArray) {
      final NativeArray na = (NativeArray) ret;
      final Document[] mapped = new Document[(int) na.getLength()];
      for (int i = 0; i < (int) na.getLength(); i++) {
        ret = na.get(i, null);
        if (!(ret instanceof RhinoDocument)) {
          throw new RuntimeException("Invalid object type: " + ret.getClass().getName());
        }
        mapped[i] = ((RhinoDocument) ret).doc;
      }
      return mapped;
    }

    throw new RuntimeException("Invalid object type: " + ret.getClass().getName());
  }
  public static void loadExhibitDataFile(
      Reader baseReader,
      String url,
      String namespace,
      Map<String, NativeObject> types,
      Map<String, NativeObject> properties,
      List<NativeObject> items)
      throws IOException {
    ChainingReader reader = new ChainingReader();
    reader.addReader(new StringReader("("));
    reader.addReader(baseReader);
    reader.addReader(new StringReader(")"));

    try {
      Context context = Context.enter();
      Scriptable scope = context.initStandardObjects();

      Object o = context.evaluateReader(scope, reader, url, 1, null);
      if (o instanceof NativeObject) {
        NativeObject no = (NativeObject) o;

        Object typesO = ScriptableObject.getProperty(no, "types");
        if (typesO instanceof NativeObject) {
          NativeObject typesNO = (NativeObject) typesO;
          Object[] propertiesIds = ScriptableObject.getPropertyIds(typesNO);

          for (Object propertyId : propertiesIds) {
            String typeID = propertyId.toString();
            Object typeO = ScriptableObject.getProperty(typesNO, typeID);
            if (typeO instanceof NativeObject) {
              types.put(typeID, (NativeObject) typeO);
            }
          }
        }

        Object propertiesO = ScriptableObject.getProperty(no, "properties");
        if (propertiesO instanceof NativeObject) {
          NativeObject propertiesNO = (NativeObject) propertiesO;
          Object[] propertiesIds = ScriptableObject.getPropertyIds(propertiesNO);

          for (Object propertyId : propertiesIds) {
            String propertyID = propertyId.toString();
            Object propertyO = ScriptableObject.getProperty(propertiesNO, propertyID);
            if (propertyO instanceof NativeObject) {
              properties.put(propertyID, (NativeObject) propertyO);
            }
          }
        }

        Object itemsO = ScriptableObject.getProperty(no, "items");
        if (itemsO instanceof NativeArray) {
          NativeArray itemsArray = (NativeArray) itemsO;

          long count = itemsArray.getLength();
          for (int i = 0; i < count; i++) {
            Object itemO = itemsArray.get(i, itemsArray);
            if (itemO instanceof NativeObject) {
              items.add((NativeObject) itemO);
            }
          }
        }
      }
    } finally {
      reader.close();
    }
  }
  protected static Resource _processItem(
      NativeObject itemNO,
      String baseURL,
      SailConnection dataConnection,
      SailConnection metaConnection,
      Map<String, String> itemIDToURI)
      throws SailException {
    String id = _getStringProperty(itemNO, "id");
    String label = _getStringProperty(itemNO, "label");
    String uri = _getStringProperty(itemNO, "uri");

    if (id == null) {
      if (label == null) {
        throw new InternalError("Missing both label and id");
      } else {
        id = label;
      }
    }

    Resource itemResource;
    try {
      itemResource = new URIImpl(uri);
    } catch (Exception e) {
      uri = baseURL + _encode(id);
      itemResource = new URIImpl(uri);
    }

    String typeID = _getStringProperty(itemNO, "type");
    Resource type;
    if (typeID == null) {
      type = ExhibitOntology.ITEM;
    } else {
      type = _ensureTypeExists(typeID, baseURL, metaConnection);
    }

    dataConnection.addStatement(itemResource, RDF.TYPE, type);
    dataConnection.addStatement(itemResource, ExhibitOntology.ID, new LiteralImpl(id));
    if (label != null) {
      dataConnection.addStatement(itemResource, RDFS.LABEL, new LiteralImpl(label));
    }

    Object[] propertiesIds = ScriptableObject.getPropertyIds(itemNO);
    for (Object propertyId : propertiesIds) {
      String propertyID = propertyId.toString();
      if (!propertyID.equals("type")
          && !propertyID.equals("label")
          && !propertyID.equals("uri")
          && !propertyID.equals("id")) {

        URI predicate = _ensurePropertyExists(propertyID, baseURL, metaConnection);

        Object valueO = ScriptableObject.getProperty(itemNO, propertyID);
        if (valueO instanceof NativeArray) {
          NativeArray valuesArray = (NativeArray) valueO;

          long count = valuesArray.getLength();
          for (int i = 0; i < count; i++) {
            Object itemO = valuesArray.get(i, valuesArray);

            _addItemProperty(
                itemResource,
                predicate,
                itemO,
                baseURL,
                dataConnection,
                metaConnection,
                itemIDToURI);
          }
        } else {
          _addItemProperty(
              itemResource,
              predicate,
              valueO,
              baseURL,
              dataConnection,
              metaConnection,
              itemIDToURI);
        }
      }
    }

    return itemResource;
  }
Example #12
0
 @Test
 public void getShouldReturnNormalProperties() {
   array.put("p", array, "a");
   assertThat((String) array.get("p", array), is("a"));
 }