public void testCompareAndSet() {
    double prev = Math.E;
    double unused = Math.E + Math.PI;
    AtomicDouble at = new AtomicDouble(prev);
    for (double x : VALUES) {
      assertBitEquals(prev, at.get());
      assertFalse(at.compareAndSet(unused, x));
      assertBitEquals(prev, at.get());
      assertTrue(at.compareAndSet(prev, x));
      assertBitEquals(x, at.get());
      prev = x;
    }
  }

    for (int i : new int[] {0, SIZE - 1}) {
      double prev = 0.0;
      double unused = Math.E + Math.PI;
      for (double x : VALUES) {
        assertBitEquals(prev, aa.get(i));
        assertFalse(aa.compareAndSet(i, unused, x));
        assertBitEquals(prev, aa.get(i));
        assertTrue(aa.compareAndSet(i, prev, x));
        assertBitEquals(x, aa.get(i));
        prev = x;
      }
    }
  }

  public void testCompareAndSet() {
    double prev = Math.E;
    double unused = Math.E + Math.PI;
    AtomicDouble at = new AtomicDouble(prev);
    for (double x : VALUES) {
      assertBitEquals(prev, at.get());
      assertFalse(at.compareAndSet(unused, x));
      assertBitEquals(prev, at.get());
      assertTrue(at.compareAndSet(prev, x));
      assertBitEquals(x, at.get());
      prev = x;
    }
  }

    for (int i : new int[] {0, SIZE - 1}) {
      double prev = 0.0;
      double unused = Math.E + Math.PI;
      for (double x : VALUES) {
        assertBitEquals(prev, aa.get(i));
        assertFalse(aa.compareAndSet(i, unused, x));
        assertBitEquals(prev, aa.get(i));
        assertTrue(aa.compareAndSet(i, prev, x));
        assertBitEquals(x, aa.get(i));
        prev = x;
      }
    }
  }

	if err == nil {
		return
	}

	nerr := unwrapErrs(err)
	l.Lock()
	shouldLog := true
	prev, ok := l.IDMap[id]
	if !ok {
		l.IDMap[id] = onceErr{
			Err:   nerr,
			Count: 1,
		}
	} else if prev.Err.Error() == nerr.Error() {
		// if errors are equal do not log.
		prev.Count++
		l.IDMap[id] = prev
		shouldLog = false
	}
	l.Unlock()

	if shouldLog {
		consoleLogIf(ctx, subsystem, err, errKind...)

        Lifecycle.Phase prev = null;
        for (Lifecycle.Phase child : phases) {
            // add phase
            addPhase(graph, before, after, child);
            if (prev != null) {
                // add link between end of previous phase and beginning of this one
                graph.addEdge(graph.addVertex(AFTER + prev.name()), graph.addVertex(BEFORE + child.name()));
            }

    checkNotNull(comparator);
    Iterator<? extends T> it = iterable.iterator();
    if (it.hasNext()) {
      T prev = it.next();
      while (it.hasNext()) {
        T next = it.next();
        if (comparator.compare(prev, next) > 0) {
          return false;
        }
        prev = next;
      }
    }
    return true;
  }

  /**

func evalSQLLike(text, pattern string, escape rune) (match bool, err error) {
	s := []rune{}
	prev := runeZero
	hasLeadingPercent := false
	patLen := len([]rune(pattern))
	for i, r := range pattern {
		if i > 0 && prev == escape {
			switch r {
			case percent, escape, underscore:
				s = append(s, r)
				prev = r
				if r == escape {
					prev = runeZero
				}
			default:
				return false, errMalformedEscapeSequence
			}

        reader.addSort(SortBuilders.fieldSort("field2"));
        int count = 0;
        int prev = -1;
        Map<String, Object> source;
        while ((source = reader.read()) != null) {
            int current = Integer.parseInt(source.get("field2").toString());
            assertTrue(prev < current);
            prev = current;
            count++;
        }
        assertEquals(num, count);

        (save-excursion
          (end-of-line)
          (let ((endpoint (point)))
            (beginning-of-line)
            (if (re-search-forward "[ ]*);$" endpoint t) t nil))))

      (defun my/prev-line-call-with-no-args-p ()
        "Return true if the previous line is a function call with no arguments"
        (save-excursion
          (let ((start (point)))
            (forward-line -1)