"testing"
)

func TestFixLongPath(t *testing.T) {
	// 248 is long enough to trigger the longer-than-248 checks in
	// fixLongPath, but short enough not to make a path component
	// longer than 255, which is illegal on Windows. (which
	// doesn't really matter anyway, since this is purely a string
	// function we're testing, and it's not actually being used to
	// do a system call)
	veryLong := "l" + strings.Repeat("o", 248) + "ng"

'\''         // rune literal containing single quote character
'aa'         // illegal: too many characters
'\k'         // illegal: k is not recognized after a backslash
'\xa'        // illegal: too few hexadecimal digits
'\0'         // illegal: too few octal digits
'\400'       // illegal: octal value over 255
'\uDFFF'     // illegal: surrogate half
'\U00110000' // illegal: invalid Unicode code point
</pre>

        Settings settings = new Settings();
        Mirror mirror = new Mirror();
        mirror.setId("local");
        settings.addMirror(mirror);
        mirror = new Mirror();
        mirror.setId("illegal\\:/chars");
        mirror.setUrl("http://void");
        mirror.setMirrorOf("void");
        settings.addMirror(mirror);

        SimpleProblemCollector problems = new SimpleProblemCollector();

        List<Throwable> errors = new ArrayList<>();
        errors.add(new Exception("Exception error"));
        errors.add(new RuntimeException("Runtime error"));
        errors.add(new IllegalArgumentException("Illegal argument error"));

        SuggestDeleteResponse response = new SuggestDeleteResponse(errors, 150);

        assertTrue(response.hasError());
        assertEquals(3, response.getErrors().size());

        switch (requestType) {
            case REQUEST_PUT:
                break;
            case REQUEST_GET:
                break;
            default:
                throw new IllegalArgumentException("Illegal request type: " + requestType);
        }

        this.requestType = requestType;
    }

    /**
     * @return Returns the eventType.
     */
    public int getEventType() {

    assertEquals(written, counter.getCount());

    counter.write(data, 2, 5);
    written += 5;
    assertEquals(written, out.size());
    assertEquals(written, counter.getCount());

    // Test that illegal arguments do not affect count
    assertThrows(IndexOutOfBoundsException.class, () -> counter.write(data, 0, data.length + 1));
    assertEquals(written, out.size());
    assertEquals(written, counter.getCount());
  }

     * .
     */
    @Test
    public void testToBinaryException() {
        exception.expect(ClIllegalArgumentException.class);
        exception.expectMessage(is("[ECL0009]argument[o] is illegal. because class java.lang.Object."));
        BinaryConversionUtil.toBinary(new Object());
    }

      } while ((byte1 = bytes[index++]) >= 0);

      if (byte1 < (byte) 0xE0) {
        // Two-byte form.
        if (index == end) {
          return false;
        }
        // Simultaneously check for illegal trailing-byte in leading position
        // and overlong 2-byte form.
        if (byte1 < (byte) 0xC2 || bytes[index++] > (byte) 0xBF) {
          return false;
        }
      } else if (byte1 < (byte) 0xF0) {

      } while ((byte1 = bytes[index++]) >= 0);

      if (byte1 < (byte) 0xE0) {
        // Two-byte form.
        if (index == end) {
          return false;
        }
        // Simultaneously check for illegal trailing-byte in leading position
        // and overlong 2-byte form.
        if (byte1 < (byte) 0xC2 || bytes[index++] > (byte) 0xBF) {
          return false;
        }
      } else if (byte1 < (byte) 0xF0) {

	{"3>>-4", "negative right shift count"},
	{"3>>(1<<63)", "negative right shift count"},
	{"(1<<63)>>2", "right shift of value with high bit set"},
	{"(1<<62)>>2", ""},
	{`'\x80'`, "illegal UTF-8 encoding for character constant"},
	{"(23*4", "missing closing paren"},
	{")23*4", "unexpected ) evaluating expression"},
	{"18446744073709551616", "value out of range"},
}

func TestBadExpr(t *testing.T) {