How to use

OrgRange

in

com.orgzly.org.datetime

  if (scheduled.shift()) {
    shifted = true;
  if (deadline.shift()) {
  closed = new OrgRange(new OrgDateTime(false));
closed = new OrgRange(new OrgDateTime(false));

/** Parse all plain timestamps in this content and rebuild the timestamps list. */
private void reparse() {
  timestamps.clear();
  Matcher m = OrgPatterns.DT_OR_RANGE_P.matcher(toString());
  while (m.find()) {
    timestamps.add(OrgRange.parse(m.group()));
  }
  dirty = false;
}

public boolean hasClosed() {
  return closed != null && closed.isSet();
}

@Test
public void testRangeWith3Dashes() {
  OrgRange time = OrgRange.parse("[2000-01-01 00:12 .+1h]---<2000-02-02 Mon +1d>");
  Assert.assertNotNull(time.getStartTime());
  Assert.assertNotNull(time.getEndTime());
}

  @Test
  public void testTimeShift() {
    OrgRange range = OrgRange.parse(timestamp);

    Assert.assertEquals(isShifted, range.shift(now));

    Assert.assertEquals(expected, range.toStringWithoutBrackets());
  }
}

@Test
public void testFromString1() {
  OrgRange time = OrgRange.parse("[2000-01-01]--<2000-02-02 10:20>");
  Assert.assertNotNull(time);
  Assert.assertNotNull(time.getStartTime());
  Assert.assertNotNull(time.getEndTime());
  Assert.assertEquals("[2000-01-01]", time.getStartTime().toString());
  Assert.assertFalse(time.getStartTime().isActive());
  Assert.assertEquals("<2000-02-02 10:20>", time.getEndTime().toString());
  Assert.assertTrue(time.getEndTime().isActive());
  Assert.assertEquals("[2000-01-01]--<2000-02-02 10:20>", time.toString());
}

  @Test
  public void testFromNoteToTodoWithRepeater() {
    StateChangeLogic scl  = new StateChangeLogic(new HashSet<>(Arrays.asList("DONE")));
    scl.setState("NEXT", "NOTE", OrgRange.parse("<2018-02-06 Tue +7d>"), null);
    assertEquals("NEXT", scl.getState());
    assertEquals("<2018-02-06 Tue +7d>", scl.getScheduled().toString());
    assertNull(scl.getClosed());
  }
}

@Test
public void testGeneratedString1() {
  OrgRange range = OrgRange.parse("<2009-10-17 13:15-14:30 ++1y --2d>--<2015-01-18>");
  Assert.assertEquals("2009-10-17 Sat 13:15-14:30 ++1y --2d--2015-01-18 Sun", range.toStringWithoutBrackets());
}

OrgRange t = new OrgRange();

public boolean shift() {
  return shift(Calendar.getInstance());
}

@Test
public void testPlainTimestamps() throws IOException {
  String str = "* Node\n" +
    "CLOSED: [2012-12-29 Sat 08:05] DEADLINE: <2012-12-28 Fri> SCHEDULED: <2012-12-27 Thu>\n" +
    "<2018-01-15 Mon> some text between timestamps <2018-01-16 Tue>\n" +
    "Blabla some other text in front <2018-01-17 Wed> text after\n" +
    "\n\n" +
    "[2018-01-18 Thu]\n\n";
  OrgParsedFile file = parserBuilder.setInput(str).build().parse();
  List<OrgRange> timestamps = file.getHeadsInList().get(0).getHead().getTimestamps();
  Assert.assertEquals(4, timestamps.size());
  Assert.assertEquals("<2018-01-15 Mon>", timestamps.get(0).toString());
  Assert.assertEquals("<2018-01-16 Tue>", timestamps.get(1).toString());
  Assert.assertEquals("<2018-01-17 Wed>", timestamps.get(2).toString());
  Assert.assertEquals("[2018-01-18 Thu]", timestamps.get(3).toString());
}

  @Test
  public void testDoParseInvalid() {
    OrgRange time = OrgRange.doParse("2014-05-26 Mon");
    Assert.assertNull(time);
  }
}

@Test
public void testComplicatedTimestamp() throws IOException {
  String fileContent =
      "** TODO Shave\n" +
      "SCHEDULED: <2009-10-17 Sat .+2d/4d>\n" +
      "   - State \"DONE\"       from \"TODO\"       [2009-10-15 Thu]\n" +
      "   - State \"DONE\"       from \"TODO\"       [2009-10-12 Mon]\n" +
      "   :PROPERTIES:\n" +
      "   :STYLE:    habit\n" +
      "   :LAST_REPEAT: [2009-10-19 Mon 00:36]\n" +
      "   :END:";
  OrgParsedFile file = parserBuilder.setInput(fileContent).build().parse();
  Assert.assertEquals("", file.getFile().getPreface());
  Assert.assertEquals("Shave", file.getHeadsInList().get(0).getHead().getTitle());
  Assert.assertEquals("<2009-10-17 Sat .+2d/4d>", file.getHeadsInList().get(0).getHead().getScheduled().getStartTime().toString());
  Assert.assertEquals("** TODO Shave\n" +
            "SCHEDULED: <2009-10-17 Sat .+2d/4d>\n" +
            "   - State \"DONE\"       from \"TODO\"       [2009-10-15 Thu]\n" +
            "   - State \"DONE\"       from \"TODO\"       [2009-10-12 Mon]\n" +
            "   :PROPERTIES:\n" +
            "   :STYLE:    habit\n" +
            "   :LAST_REPEAT: [2009-10-19 Mon 00:36]\n" +
            "   :END:\n\n", file.toString());
}

@Test
public void testRangeWithRepeaterAndHabitDeadline() {
  OrgRange time = OrgRange.parse("<2015-01-11 Sun .+1d/2d>");
  Assert.assertNotNull(time.getStartTime());
  Assert.assertNull(time.getEndTime());
}

@Test
public void testFromNoteToDoneWithRepeater() {
  StateChangeLogic scl  = new StateChangeLogic(new HashSet<>(Arrays.asList("DONE")));
  scl.setState("DONE", "NOTE", OrgRange.parse("<2018-02-06 Tue +7d>"), null);
  assertEquals("NOTE", scl.getState());
  assertEquals("<2018-02-13 Tue +7d>", scl.getScheduled().toString());
  assertNull(scl.getClosed());
}

@Test
public void testGetInstanceForNullOrgDateTime() {
  try {
    new OrgRange(null);
    Assert.fail("Parsing null OrgDateTime must throw exception");
  } catch (IllegalArgumentException e) {
    Assert.assertTrue(e.getMessage().equals("OrgRange cannot be created from null OrgDateTime"));
  }
}

@Test
public void testTimestampMultiline() {
  OrgContent o = new OrgContent();
  o.append("<2000-01-01 10:10>\n<2001-01-01 10:10>");
  Assert.assertEquals(2, o.getTimestamps().size());
  Assert.assertEquals("<2000-01-01 10:10>", o.getTimestamps().get(0).toString());
  Assert.assertEquals("<2001-01-01 10:10>", o.getTimestamps().get(1).toString());
}

@Test
public void testDoParse() {
  OrgRange time = OrgRange.doParse("[2014-05-26 Mon]");
  Assert.assertNotNull(time);
}

@Test
public void testRangeWithOneDash() {
  OrgRange time = OrgRange.parse("[2000-01-01 00:12 .+1h]-<2000-02-02 Mon +1d>");
  Assert.assertNotNull(time.getStartTime());
  Assert.assertNotNull(time.getEndTime());
}

public static OrgRange parseOrNull(String str) {
  if (OrgStringUtils.isEmpty(str)) {
    return null;
  }
  return parse(str);
}