bool1 = "${1 > 2}"
                    bool2 = "${2 > 1}"
                    theBoolean = "${3 > 2}"
                    theDouble = "${Math.PI - 1}"
                    thedouble = "${Math.E - 1}"
                    thefloat = "${Math.PI - 2}"
                    theFloat = "${Math.E - 2}"
                    theint = "${1 + 2}"
                    theInteger = "${3 + 5}"

ner.removeChild(this.fakeElem),this.fakeElem=null)}},{key:"selectTarget",value:function(){this.selectedText=(0,c.default)(this.target),this.copyText()}},{key:"copyText",value:function(){var e=void 0;try{e=document.execCommand(this.action)}catch(t){e=!1}this.handleResult(e)}},{key:"handleResult",value:function(t){this.emitter.emit(t?"success":"error",{action:this.action,text:this.selectedText,trigger:this.trigger,clearSelection:this.clearSelection.bind(this)})}},{key:"clearSelection",value:functi...

000002b0  3e 9b 3b 4f 90 0f d2 9b  50 11 fe df 1f 12 f2 d9  |>.;O....P.......|
000002c0  0d 89 bc 6c 01 93 45 ca  b8 3c 09 cf b2 01 e9 99  |...l..E..<......|
000002d0  87 fb 1d ac 91 7f 77 a2  21 5e 07 5e 65 3b ec 31  |......w.!^.^e;.1|
000002e0  d7 b5 b9 1d 88 c8 82 f5  03 a9 37 e8 b9 02 42 01  |..........7...B.|
000002f0  78 c4 90 fb e3 7f 5a 7a  66 0a 44 f5 66 0e 1e ac  |x.....Zzf.D.f...|

                && ms1.comparator().equals(ms2.comparator());
    CollectorTester.of(
            ImmutableSortedMultiset.<String, String>toImmutableSortedMultiset(
                String.CASE_INSENSITIVE_ORDER, e -> e, e -> 1),
            equivalence)
        .expectCollects(ImmutableSortedMultiset.emptyMultiset(String.CASE_INSENSITIVE_ORDER))
        .expectCollects(
            ImmutableSortedMultiset.orderedBy(String.CASE_INSENSITIVE_ORDER)

   * encounter order.
   *
   * @since 21.0
   */
  public static <E> Collector<E, ?, ImmutableMultiset<E>> toImmutableMultiset() {
    return CollectCollectors.toImmutableMultiset(Function.identity(), e -> 1);
  }

  /**
   * Returns a {@code Collector} that accumulates elements into an {@code ImmutableMultiset} whose
   * elements are the result of applying {@code elementFunction} to the inputs, with counts equal to

            a,
            b1,
            c,
            b2);
    collector = ImmutableMultiset.toImmutableMultiset(e -> e, e -> 1);
    CollectorTester.of(collector, equivalence)
        .expectCollects(
            ImmutableMultiset.<TypeWithDuplicates>builder().add(a).addCopies(b1, 2).add(c).build(),
            a,
            b1,

        when:
        source api: ["class A { public static final int EVIL = 0; }"]
        run("impl:${language.compileTaskName}")

        then:
        impl.recompiledClasses('C', 'C$Inner', 'D', 'D$Inner', 'E', 'E$1', 'F', 'F$Inner')

        where:
        visibility << ['public', 'private', '']
    }

    def "recognizes change of constant value in annotation"() {
        source api: [

  @IgnoreJRERequirement // Users will use this only if they're already using streams.
  public static <E> Collector<E, ?, ImmutableMultiset<E>> toImmutableMultiset() {
    return CollectCollectors.toImmutableMultiset(Function.identity(), e -> 1);
  }

  /**
   * Returns a {@code Collector} that accumulates elements into an {@code ImmutableMultiset} whose
   * elements are the result of applying {@code elementFunction} to the inputs, with counts equal to

	// A very large number (initially wrongly parsed by the fast algorithm).
	"4.630813248087435e+307",

	// A different kind of very large number.
	"22.222222222222222",
	"long:2." + strings.Repeat("2", 4000) + "e+1",

	// Exactly halfway between 1 and math.Nextafter(1, 2).
	// Round to even (down).
	"1.00000000000000011102230246251565404236316680908203125",
	// Slightly lower; still round down.

			t.Errorf("RuneCount(%q) = %d, want %d", tt.in, out, tt.out)
		}
	}
}

type RuneLenTest struct {
	r    rune
	size int
}

var runelentests = []RuneLenTest{
	{0, 1},
	{'e', 1},
	{'é', 2},
	{'☺', 3},
	{RuneError, 3},
	{MaxRune, 4},
	{0xD800, -1},
	{0xDFFF, -1},
	{MaxRune + 1, -1},
	{-1, -1},
}

func TestRuneLen(t *testing.T) {