How to use

ch.qos.logback.core.subst.Node

constructor

private Node makeNewLiteralNode(String s) {
 return new Node(Node.Type.LITERAL, s);
}

private Node V() throws ScanException {
 Node e = E();
 Node variable = new Node(Node.Type.VARIABLE, e);
 Token t = peekAtCurentToken();
 if (isDefaultToken(t)) {
  advanceTokenPointer();
  Node def = E();
  variable.defaultPart = def;
 }
 return variable;
}

private Node makeNewLiteralNode(String s) {
  return new Node(Node.Type.LITERAL, s);
}

private Node makeNewLiteralNode(String s) {
 return new Node(Node.Type.LITERAL, s);
}

private Node makeNewLiteralNode(String s) {
 return new Node(Node.Type.LITERAL, s);
}

@Test
public void literalVariableLiteral() throws ScanException {
 Tokenizer tokenizer = new Tokenizer("a${b}c");
 Parser parser = new Parser(tokenizer.tokenize());
 Node node = parser.parse();
 Node witness = new Node(Node.Type.LITERAL, "a");
 witness.next = new Node(Node.Type.VARIABLE, new Node(Node.Type.LITERAL, "b"));
 witness.next.next = new Node(Node.Type.LITERAL, "c");
 assertEquals(witness, node);
}

@Test
public void withColon() throws ScanException {
 Tokenizer tokenizer = new Tokenizer("a:${b}");
 Parser parser = new Parser(tokenizer.tokenize());
 Node node = parser.parse();
 Node witness = new Node(Node.Type.LITERAL, "a");
 Node t = witness.next = new Node(Node.Type.LITERAL, ":");
 t.next = new Node(Node.Type.VARIABLE, new Node(Node.Type.LITERAL, "b"));
 assertEquals(witness, node);
}

@Test
public void withDefault() throws ScanException {
 Tokenizer tokenizer = new Tokenizer("${b:-c}");
 Parser parser = new Parser(tokenizer.tokenize());
 Node node = parser.parse();
 Node witness = new Node(Node.Type.VARIABLE, new Node(Node.Type.LITERAL, "b"));
 witness.defaultPart = new Node(Node.Type.LITERAL, "c");
 assertEquals(witness, node);
}

@Test
public void literalWithAccolade1() throws ScanException {
 Tokenizer tokenizer = new Tokenizer("%x{a}");
 Parser parser = new Parser(tokenizer.tokenize());
 Node node = parser.parse();
 Node witness = new Node(Node.Type.LITERAL, "%x");
 Node t = witness.next = new Node(Node.Type.LITERAL, "{");
 t.next = new Node(Node.Type.LITERAL, "a");
 t = t.next;
 t.next = new Node(Node.Type.LITERAL, "}");
 assertEquals(witness, node);
}

private Node V() throws ScanException {
 Node e = E();
 Node variable = new Node(Node.Type.VARIABLE, e);
 Token t = getCurentToken();
 if (t != null && t.type == Token.Type.DEFAULT) {
  advanceTokenPointer();
  Node def = E();
  variable.defaultPart = def;
 }
 return variable;
}

private Node V() throws ScanException {
 Node e = E();
 Node variable = new Node(Node.Type.VARIABLE, e);
 Token t = getCurentToken();
 if (t != null && t.type == Token.Type.DEFAULT) {
  advanceTokenPointer();
  Node def = E();
  variable.defaultPart = def;
 }
 return variable;
}

@Test
public void defaultSeparatorOutsideOfAVariable() throws ScanException {
 Tokenizer tokenizer = new Tokenizer("{a:-b}");
 Parser parser = new Parser(tokenizer.tokenize());
 Node node = parser.parse();
 dump(node);
 Node witness = new Node(Node.Type.LITERAL, "{");
 Node t = witness.next = new Node(Node.Type.LITERAL, "a");
 t.next = new Node(Node.Type.LITERAL, ":-");
 t = t.next;
 t.next = new Node(Node.Type.LITERAL, "b");
 t = t.next;
 t.next = new Node(Node.Type.LITERAL, "}");
 assertEquals(witness, node);
}

private Node V() throws ScanException {
  Node e = E();
  Node variable = new Node(Node.Type.VARIABLE, e);
  Token t = peekAtCurentToken();
  if (isDefaultToken(t)) {
    advanceTokenPointer();
    Node def = E();
    variable.defaultPart = def;
  }
  return variable;
}

@Test
public void variable() throws ScanException {
 Tokenizer tokenizer = new Tokenizer("${abc}");
 Parser parser = new Parser(tokenizer.tokenize());
 Node node = parser.parse();
 Node witness = new Node(Node.Type.VARIABLE, new Node(Node.Type.LITERAL, "abc"));
 assertEquals(witness, node);
}

private Node V() throws ScanException {
 Node e = E();
 Node variable = new Node(Node.Type.VARIABLE, e);
 Token t = peekAtCurentToken();
 if (isDefaultToken(t)) {
  advanceTokenPointer();
  Node def = E();
  variable.defaultPart = def;
 }
 return variable;
}

private Node V() throws ScanException {
  Node e = E();
  Node variable = new Node(Node.Type.VARIABLE, e);
  Token t = peekAtCurentToken();
  if (isDefaultToken(t)) {
    advanceTokenPointer();
    Node def = E();
    variable.defaultPart = def;
  }
  return variable;
}

private Node V() throws ScanException {
 Node e = E();
 Node variable = new Node(Node.Type.VARIABLE, e);
 Token t = peekAtCurentToken();
 if (isDefaultToken(t)) {
  advanceTokenPointer();
  Node def = E();
  variable.defaultPart = def;
 }
 return variable;
}

private Node V() throws ScanException {
  Node e = E();
  Node variable = new Node(Node.Type.VARIABLE, e);
  Token t = peekAtCurentToken();
  if (isDefaultToken(t)) {
    advanceTokenPointer();
    Node def = E();
    variable.defaultPart = def;
  }
  return variable;
}

@Test
public void literalWithAccolade0() throws ScanException {
 Tokenizer tokenizer = new Tokenizer("{}");
 Parser parser = new Parser(tokenizer.tokenize());
 Node node = parser.parse();
 Node witness = new Node(Node.Type.LITERAL, "{");
 witness.next = new Node(Node.Type.LITERAL, "}");
 assertEquals(witness, node);
}

@Test
public void literal() throws ScanException {
 Tokenizer tokenizer = new Tokenizer("abc");
 Parser parser = new Parser(tokenizer.tokenize());
 Node node = parser.parse();
 Node witness = new Node(Node.Type.LITERAL, "abc");
 assertEquals(witness, node);
}