private static ObjectNode hasNullMapsNode() {
  ObjectNode node = newObjectNode();
  node.set("int32Map", NullNode.getInstance());
  node.set("int64Map", NullNode.getInstance());
  node.set("uint32Map", NullNode.getInstance());
  node.set("uint64Map", NullNode.getInstance());
  node.set("sint32Map", NullNode.getInstance());
  node.set("sint64Map", NullNode.getInstance());
  node.set("fixed32Map", NullNode.getInstance());
  node.set("fixed64Map", NullNode.getInstance());
  node.set("sfixed32Map", NullNode.getInstance());
  node.set("sfixed64Map", NullNode.getInstance());
  node.set("boolMap", NullNode.getInstance());
  node.set("stringMap", NullNode.getInstance());
  return node;
}
 

/**
 * Judge Java objects and create JsonNode.
 */
public static JsonNode get( final Object obj ) throws IOException {
  if ( obj instanceof PrimitiveObject ) {
    return PrimitiveObjectToJsonNode.get( (PrimitiveObject)obj );
  } else if ( obj instanceof String ) {
    return new TextNode( (String)obj );
  } else if ( obj instanceof Boolean ) {
    return BooleanNode.valueOf( (Boolean)obj );
  } else if ( obj instanceof Short ) {
    return IntNode.valueOf( ( (Short)obj ).intValue() );
  } else if ( obj instanceof Integer ) {
    return IntNode.valueOf( (Integer)obj );
  } else if ( obj instanceof Long ) {
    return new LongNode( (Long)obj );
  } else if ( obj instanceof Float ) {
    return new DoubleNode( ( (Float)obj ).doubleValue() );
  } else if ( obj instanceof Double ) {
    return new DoubleNode( (Double)obj );
  } else if ( obj instanceof byte[] ) {
    return new BinaryNode( (byte[])obj );
  } else if ( obj == null ) {
    return NullNode.getInstance();
  } else {
    return new TextNode( obj.toString() );
  }
}
 

@Activate
public void activate() {
    KryoNamespace.Builder kryoBuilder = new KryoNamespace.Builder()
            .register(KryoNamespaces.API)
            .register(ConfigKey.class, ObjectNode.class, ArrayNode.class,
                      JsonNodeFactory.class, LinkedHashMap.class,
                      TextNode.class, BooleanNode.class,
                      LongNode.class, DoubleNode.class, ShortNode.class, IntNode.class,
                      NullNode.class);

    configs = storageService.<ConfigKey, JsonNode>consistentMapBuilder()
            .withSerializer(Serializer.using(kryoBuilder.build()))
            .withName("onos-network-configs")
            .withRelaxedReadConsistency()
            .build();
    configs.addListener(listener);
    log.info("Started");
}
 

JsonNode valueOrNull(String name) {
  Objects.requireNonNull(name, "name");

  if (fields != null && fields.has(name)) {
    JsonNode field = fields.get(name);
    if (field.isArray()) {
      // return first element (or null)
      Iterator<JsonNode> iter = field.elements();
      return iter.hasNext() ? iter.next() : null;
    }

    return field;
  }

  JsonNode found = source().at(name);
  return found.isMissingNode() ? NullNode.getInstance() : found;
}
 

public JsonNode call(JsonNode input, JsonNode[] arguments) {
  String json = NodeUtils.toString(arguments[0], true);
  if (json == null)
    return NullNode.instance;

  try {
    JsonNode parsed = NodeUtils.mapper.readTree(json);
    if (parsed == null) // if input is "", for example
      return NullNode.instance;
    return parsed;
  } catch (Exception e) {
    if (arguments.length == 2)
      return arguments[1]; // return fallback on parse fail
    else
      throw new JsltException("from-json can't parse " + json + ": " + e);
  }
}
 

public JsonNode perform(JsonNode v1, JsonNode v2) {
  if (v1.isNull() || v2.isNull())
    return NullNode.instance;

  // we only support the numeric operation and nothing else
  v1 = NodeUtils.number(v1, true, location);
  v2 = NodeUtils.number(v2, true, location);

  if (v1.isIntegralNumber() && v2.isIntegralNumber()) {
    long l1 = v1.longValue();
    long l2 = v2.longValue();
    if (l1 % l2 == 0)
      return new LongNode(l1 / l2);
    else
      return new DoubleNode((double) l1 / (double) l2);
  } else
    return new DoubleNode(perform(v1.doubleValue(), v2.doubleValue()));
}
 

public Object extract(ObjectNode node, RakamHttpRequest request)
{
    JsonNode value = node.get(name);
    Object o;
    if (value == null) {
        o = null;
    }
    else {
        try {
            o = mapper.convertValue(value, type);
        }
        catch (IllegalArgumentException e) {
            throw new HttpRequestException(name +
                    " body parameter cannot be cast to " + type.toString() + ": "+e.getMessage(), BAD_REQUEST);
        }
    }

    if (required && (o == null || o == NullNode.getInstance())) {
        throw new HttpRequestException(name + " body parameter is required", BAD_REQUEST);
    }

    return o;
}
 

@Override
public Ports deserialize(JsonParser jsonParser, DeserializationContext deserializationContext)
        throws IOException {

    Ports out = new Ports();
    ObjectCodec oc = jsonParser.getCodec();
    JsonNode node = oc.readTree(jsonParser);
    for (Iterator<Map.Entry<String, JsonNode>> it = node.fields(); it.hasNext(); ) {

        Map.Entry<String, JsonNode> portNode = it.next();
        JsonNode bindingsArray = portNode.getValue();
        if (bindingsArray.equals(NullNode.getInstance())) {
            out.bind(ExposedPort.parse(portNode.getKey()), null);
        } else {
            for (int i = 0; i < bindingsArray.size(); i++) {
                JsonNode bindingNode = bindingsArray.get(i);
                if (!bindingNode.equals(NullNode.getInstance())) {
                    String hostIp = bindingNode.get("HostIp").textValue();
                    String hostPort = bindingNode.get("HostPort").textValue();
                    out.bind(ExposedPort.parse(portNode.getKey()), new Binding(hostIp, hostPort));
                }
            }
        }
    }
    return out;
}
 

@Test
public void deserialize() throws Exception {
    StratumMessage m1 = readValue("{\"id\":123, \"method\":\"a.b\", \"params\":[1, \"x\", null]}");
    assertEquals(123L, (long)m1.id);
    assertEquals("a.b", m1.method);
    assertEquals(Lists.newArrayList(new IntNode(1), new TextNode("x"), NullNode.getInstance()), m1.params);
    StratumMessage m2 = readValue("{\"id\":123, \"result\":{\"x\": 123}}");
    assertTrue(m2.isResult());
    assertEquals(123L, (long)m2.id);
    assertEquals(mapper.createObjectNode().put("x", 123), m2.result);

    StratumMessage m3 = readValue("{\"id\":123, \"result\":[\"x\"]}");
    assertEquals(123L, (long)m3.id);
    //noinspection AssertEqualsBetweenInconvertibleTypes
    assertEquals(mapper.createArrayNode().add("x"), m3.result);
}
 

@Test
public void testAnnotatedSetterWithDefaultNullDeserialization() throws JsonProcessingException {
  ObjectNode node = Rosetta.getMapper().createObjectNode();
  node.put("annotatedSetterWithDefault", NullNode.getInstance());

  StoredAsJsonBean bean = Rosetta.getMapper().treeToValue(node, StoredAsJsonBean.class);
  assertThat(bean.getAnnotatedSetterWithDefault().getStringProperty()).isEqualTo("value");
}
 

@Test
public void createRoad() throws Exception {
  JsonNode road = mapper.readTree("{\"name\":\"road1\"}");

  List<PatchOperation> operations = singletonList(PatchOperation.add("", road));

  JsonNode result = underTest.apply(NullNode.getInstance(), operations);

  assertThat(result.isMissingNode(), is(false));
  assertThat(result.path("name").textValue(), is("road1"));
}
 

@Test
public void testHandleAddressQueueItemNoHistory() throws Exception {
    ECKey key = new ECKey();
    String address = key.toAddress(params).toString();
    control.replay();
    multiWallet.handleAddressQueueItem(
            new StratumMessage(1L, "blockchain.address.subscribe",
                    Lists.newArrayList(TextNode.valueOf(address)), NullNode.getInstance(), mapper));
    control.verify();
}
 

@Before
public void before() {
  road1 = new Road();
  road1.setName("road1");
  road1.setTopicName("road1");
  road1.setDescription("description");
  road1.setContactEmail("contactEmail");
  road1.setEnabled(false);
  status = new KafkaStatus();
  status.setTopicCreated(false);
  road1.setStatus(status);
  road1.setDeleted(false);

  PatchSetEmitter patchSetEmitter = new PatchSetEmitter() {

    @Override
    public void emit(PatchSet patchSet) {
      try {
        JsonNode roadJson = Optional
            .ofNullable(store.get(patchSet.getDocumentId()))
            .map(r -> mapper.convertValue(r, JsonNode.class))
            .orElse(NullNode.instance);
        JsonNode patchJson = mapper.convertValue(patchSet.getOperations(), JsonNode.class);
        JsonPatch jsonPatch = JsonPatch.fromJson(patchJson);
        JsonNode newRoadJson = jsonPatch.apply(roadJson);
        Road nnewRoad = mapper.convertValue(newRoadJson, Road.class);
        store.put(patchSet.getDocumentId(), nnewRoad);
      } catch (IOException | JsonPatchException e) {
        throw new RuntimeException(e);
      }
    }
  };

  store = new HashMap<>();
  client = new TollboothRoadAdminClient(Collections.unmodifiableMap(store), patchSetEmitter);
}
 

@Test
public void testOptionalSetterNullDeserialization() throws JsonProcessingException {
  ObjectNode node = Rosetta.getMapper().createObjectNode();
  node.put("optionalSetter", NullNode.getInstance());

  StoredAsJsonBean bean = Rosetta.getMapper().treeToValue(node, StoredAsJsonBean.class);
  assertThat(bean.getOptionalSetter()).isNotNull();
  assertThat(bean.getOptionalSetter().isPresent()).isFalse();
}
 

@Override
public byte[] create( final IParser parser ) throws IOException {
  JsonNode jsonNode;
  if ( parser == null ) {
    jsonNode = NullNode.getInstance();
  } else if ( parser.isMap() || parser.isStruct() ) {
    jsonNode = JacksonParserToJsonObject.getFromObjectParser( parser );
  } else if ( parser.isArray() ) {
    jsonNode = JacksonParserToJsonObject.getFromArrayParser( parser );
  } else {
    jsonNode = NullNode.getInstance();
  }

  return objectMapper.writeValueAsBytes( jsonNode );
}
 

@SuppressWarnings("unchecked")
@Override
public Optional<Optional<AttributeValue<U>>> deserialize(JsonNode json) {
    if (json instanceof ObjectNode) {
        AttributeValue<U> value = (AttributeValue<U>) AttributeValue.fromJson(json);
        return Optional.of(Optional.of(value));
    } else if (json instanceof NullNode) {
        return Optional.of(Optional.empty());
    } else {
        return Optional.empty();
    }
}
 

/**
 * Convert PrimitiveObject to JsonNode.
 */
public static JsonNode get( final PrimitiveObject obj ) throws IOException {
  if ( obj == null ) {
    return NullNode.getInstance();
  }
  switch ( obj.getPrimitiveType() ) {
    case BOOLEAN:
      return BooleanNode.valueOf( obj.getBoolean() );
    case BYTE:
      return IntNode.valueOf( obj.getInt() );
    case SHORT:
      return IntNode.valueOf( obj.getInt() );
    case INTEGER:
      return IntNode.valueOf( obj.getInt() );
    case LONG:
      return new LongNode( obj.getLong() );
    case FLOAT:
      return new DoubleNode( obj.getDouble() );
    case DOUBLE:
      return new DoubleNode( obj.getDouble() );
    case STRING:
      return new TextNode( obj.getString() );
    case BYTES:
      return new BinaryNode( obj.getBytes() );
    default:
      return NullNode.getInstance();
  }
}
 

@Test
public void T_create_json_withNull() throws IOException {
  ObjectMapper mapper = new ObjectMapper();
  JacksonMessageWriter writer = new JacksonMessageWriter();
  PrimitiveObject obj = null;
  byte[] result = writer.create( obj );
  JsonNode node = mapper.readTree( result );
  assertTrue( ( node instanceof NullNode ) );
}
 

@Test
public void T_create_json_withJacksonNullParser() throws IOException {
  ObjectMapper mapper = new ObjectMapper();
  JacksonMessageWriter writer = new JacksonMessageWriter();
  byte[] result = writer.create( new JacksonNullParser() );
  JsonNode node = mapper.readTree( result );
  assertTrue( ( node instanceof NullNode ) );
}
 

public JsonNode call(JsonNode input, JsonNode[] arguments) {
  JsonNode number = arguments[0];
  if (number.isNull())
    return NullNode.instance;
  else if (!number.isNumber())
    throw new JsltException("round() cannot round a non-number: " + number);

  return new LongNode(Math.round(number.doubleValue()));
}
 

@Activate
public void activate() {
    Serializer serializer = Serializer.using(KryoNamespaces.API,
                 ObjectNode.class, ArrayNode.class,
                 JsonNodeFactory.class, LinkedHashMap.class,
                 TextNode.class, BooleanNode.class,
                 LongNode.class, DoubleNode.class, ShortNode.class,
                 IntNode.class, NullNode.class, UiSessionToken.class);

    prefsConsistentMap = storageService.<String, ObjectNode>consistentMapBuilder()
            .withName(ONOS_USER_PREFERENCES)
            .withSerializer(serializer)
            .withRelaxedReadConsistency()
            .build();
    prefsConsistentMap.addListener(prefsListener);
    prefs = prefsConsistentMap.asJavaMap();

    tokensConsistentMap = storageService.<UiSessionToken, String>consistentMapBuilder()
            .withName(ONOS_SESSION_TOKENS)
            .withSerializer(serializer)
            .withRelaxedReadConsistency()
            .build();
    tokens = tokensConsistentMap.asJavaMap();

    register(core);

    log.info("Started");
}
 

@Test
public void testAnnotatedInnerFieldNullDeserialization() throws JsonProcessingException {
  ObjectNode node = Rosetta.getMapper().createObjectNode();
  node.set("annotatedInnerField", NullNode.getInstance());

  CustomSerializationBean bean = Rosetta.getMapper().treeToValue(node, CustomSerializationBean.class);
  assertThat(bean.getAnnotatedInnerField())
      .isNull();
}
 

public JsonNode call(JsonNode input, JsonNode[] arguments) {
  JsonNode dividend = arguments[0];
  if (dividend.isNull())
    return NullNode.instance;
  else if (!dividend.isNumber())
    throw new JsltException("mod(): dividend cannot be a non-number: " + dividend);

  JsonNode divisor = arguments[1];
  if (divisor.isNull())
    return NullNode.instance;
  else if (!divisor.isNumber())
    throw new JsltException("mod(): divisor cannot be a non-number: " + divisor);

  if (!dividend.isIntegralNumber() || !divisor.isIntegralNumber()) {
    throw new JsltException("mod(): operands must be integral types");
  } else {
    long D = dividend.longValue();
    long d = divisor.longValue();
    if (d == 0)
      throw new JsltException("mod(): cannot divide by zero");

    long r = D % d;
    if (r < 0) {
      if (d > 0)
        r += d;
      else
        r -= d;
    }

    return new LongNode(r);
  }
}
 

public JsonNode call(JsonNode input, JsonNode[] arguments) {
  JsonNode node = arguments[0];
  if (node.isNull())
    return NullNode.instance;
  try {
    // https://stackoverflow.com/a/18993481/90580
    final Object obj = mapper.treeToValue(node, Object.class);
    String jsonString = writer.writeValueAsString(obj);
    return new IntNode(jsonString.hashCode());
  } catch (JsonProcessingException e) {
    throw new JsltException("hash-int: can't process json" + e);
  }
}
 

public JsonNode call(Scope scope, JsonNode input,
                     ExpressionNode[] parameters) {
  // making this a macro means we can evaluate only the parameters
  // that are necessary to find a value, and leave the rest
  // untouched, giving better performance

  for (int ix = 0; ix < parameters.length; ix++) {
    JsonNode value = parameters[ix].apply(scope, input);
    if (NodeUtils.isValue(value))
      return value;
  }
  return NullNode.instance;
}
 

private Object jsonNodeToValue(JsonNode node) {

        Object value = node;
        if (node instanceof NullNode) {
            value = null;
        } else if (node instanceof TextNode) {
            value = node.asText();
        } else if (node instanceof BooleanNode) {
            value = node.asBoolean();
        } else if (node instanceof IntNode) {
            value = node.asInt();
        } else if (node instanceof FloatNode) {
            value = (float)((FloatNode)node).asDouble();
        } else if (node instanceof DoubleNode) {
            value = (float)((DoubleNode)node).asDouble();
        } else if (node instanceof ArrayNode) {

            int numItems = node.size();
            String[] values = new String[numItems];
            for (int i = 0; i < numItems; i++) {
                values[i] = node.path(i).asText();
            }

            value = values;
        }

        return (value);
    }
 

public JsonNode call(JsonNode input, JsonNode[] arguments) {
  JsonNode number = NodeUtils.number(arguments[0], null);
  if (number == null || number.isNull())
    return NullNode.instance;

  double timestamp = number.asDouble();

  String formatstr = NodeUtils.toString(arguments[1], false);

  TimeZone zone = new SimpleTimeZone(0, "UTC");
  if (arguments.length == 3) {
    String zonename = NodeUtils.toString(arguments[2], false);
    if (!zonenames.contains(zonename))
      throw new JsltException("format-time: Unknown timezone " + zonename);
    zone = TimeZone.getTimeZone(zonename);
  }

  // the performance of this could be better, but it's not so easy
  // to fix that when SimpleDateFormat isn't thread-safe, so we
  // can't safely share it between threads

  try {
    SimpleDateFormat format = new SimpleDateFormat(formatstr);
    format.setTimeZone(zone);
    String formatted = format.format(Math.round(timestamp * 1000));
    return new TextNode(formatted);
  } catch (IllegalArgumentException e) {
    // thrown if format is bad
    throw new JsltException("format-time: Couldn't parse format '" + formatstr + "': " + e.getMessage());
  }
}
 

@Test
public void testAnnotatedGetterNullDeserialization() throws JsonProcessingException {
  ObjectNode node = Rosetta.getMapper().createObjectNode();
  node.put("annotatedGetter", NullNode.getInstance());

  StoredAsJsonBean bean = Rosetta.getMapper().treeToValue(node, StoredAsJsonBean.class);
  assertThat(bean.getAnnotatedGetter()).isNull();
}
 

public JsonNode call(JsonNode input, JsonNode[] arguments) {
  if (arguments[0].isNull())
    return NullNode.instance;

  String urlString = arguments[0].asText();

  try {
    URL aURL = new URL(arguments[0].asText());
    final ObjectNode objectNode = NodeUtils.mapper.createObjectNode();
    if (aURL.getHost() != null && !aURL.getHost().isEmpty())
      objectNode.put("host", aURL.getHost());
    if (aURL.getPort() != -1)
      objectNode.put("port", aURL.getPort());
    if (!aURL.getPath().isEmpty())
      objectNode.put("path", aURL.getPath());
    if (aURL.getProtocol() != null && !aURL.getProtocol().isEmpty())
      objectNode.put("scheme", aURL.getProtocol());
    if (aURL.getQuery() != null && !aURL.getQuery().isEmpty()) {
      objectNode.put("query", aURL.getQuery());
      final ObjectNode queryParamsNode = NodeUtils.mapper.createObjectNode();
      objectNode.set("parameters", queryParamsNode);
      final String[] pairs = aURL.getQuery().split("&");
      for (String pair : pairs) {
        final int idx = pair.indexOf("=");
        final String key = idx > 0 ? URLDecoder.decode(pair.substring(0, idx), "UTF-8") : pair;
        if (!queryParamsNode.has(key)) queryParamsNode.set(key, NodeUtils.mapper.createArrayNode());
        final String value = idx > 0 && pair.length() > idx + 1 ? URLDecoder.decode(pair.substring(idx + 1), "UTF-8") : null;
        final ArrayNode valuesNode = (ArrayNode) queryParamsNode.get(key);
        valuesNode.add(value);
      }
    }
    if(aURL.getRef() != null)
      objectNode.put("fragment", aURL.getRef());
    if(aURL.getUserInfo() != null && !aURL.getUserInfo().isEmpty())
      objectNode.put("userinfo", aURL.getUserInfo());
    return objectNode;
  } catch (MalformedURLException | UnsupportedEncodingException e) {
    throw new JsltException("Can't parse " + urlString, e);
  }
}
 

@Test
public void testAnnotatedFieldNullDeserialization() throws JsonProcessingException {
  ObjectNode node = Rosetta.getMapper().createObjectNode();
  node.put("annotatedField", NullNode.getInstance());

  StoredAsJsonBean bean = Rosetta.getMapper().treeToValue(node, StoredAsJsonBean.class);
  assertThat(bean.getAnnotatedField()).isNull();
}