val parts =
    when {
      requestLine != null -> requestLine.split(' ', limit = 3)
      else -> return DEFAULT_REQUEST_LINE_HTTP_1
    }

  if (parts.size != 3) {
    throw ProtocolException("unexpected request line: $requestLine")
  }

  return RequestLine(
    method = parts[0],
    target = parts[1],
    version = parts[2],
  )
}

internal class RequestLine(
  val method: String,

				}
			}
			// what is absent in exp is absent in got too
			for k := range got {
				if _, ok := exp[k]; !ok && got[k] > 0 {
					t.Fatalf("Unexpected interval: %s has value %d\n", k, got[k])
				}
			}
		})
	}
}

func TestMigrateSizeHistogramFromV1(t *testing.T) {
	tests := []struct {
		v    sizeHistogramV1
		want sizeHistogram
	}{
		{

				t.Error(err)
			}
			tmpfile.WriteString(testCase.stat)
			tmpfile.Sync()
			tmpfile.Close()

			iostats, err := readDriveStats(tmpfile.Name())
			if err != nil && !testCase.expectErr {
				t.Fatalf("unexpected err; %v", err)
			}
			if testCase.expectErr && err == nil {
				t.Fatal("expected to fail but err is nil")
			}
			if !reflect.DeepEqual(iostats, testCase.expectedIOStats) {

		},
	}
	for i, test := range cases {
		listKey, item := splitPath(test.path, test.secondIndex)
		if listKey != test.expectedListKey || item != test.expectedItem {
			t.Errorf("unexpected result on test[%v]: expected[%s, %s] but got [%s, %s]", i, test.expectedListKey, test.expectedItem, listKey, item)
		}
	}

	res := jsonResult{}
	if err = json.Unmarshal([]byte(strings.ReplaceAll(jsonReq, "%%", "%")), &res); err != nil {
		t.Fatal(err)
	}

	// Look for expected method.
	if res.Method != http.MethodGet {
		t.Fatalf("Unexpected method %s, expected 'GET'", res.Method)
	}

	// Look for expected query values
	expectedQuery := url.Values{}
	expectedQuery.Set("prefix", "Hello*World*")
	expectedQuery.Set("X-Amz-Algorithm", "AWS4-HMAC-SHA256")

	}
	r, err := NewReader(bytes.NewReader(data), int64(len(data)))
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	for _, f := range r.File {
		r, err := f.Open()
		if err != nil {
			t.Fatalf("unexpected error: %v", err)
		}
		if _, err := io.Copy(io.Discard, r); err != nil {
			t.Fatalf("unexpected error: %v", err)
		}
	}
}

func TestBaseOffsetPlusOverflow(t *testing.T) {

    }
    throw new IllegalStateException("Unexpected edge type: " + edgeType);
  }

  private static EdgeType oppositeType(EdgeType edgeType) {
    switch (edgeType) {
      case UNDIRECTED:
        return EdgeType.DIRECTED;
      case DIRECTED:
        return EdgeType.UNDIRECTED;
    }
    throw new IllegalStateException("Unexpected edge type: " + edgeType);
  }

  @Test

    }
    throw new IllegalStateException("Unexpected edge type: " + edgeType);
  }

  private static EdgeType oppositeType(EdgeType edgeType) {
    switch (edgeType) {
      case UNDIRECTED:
        return EdgeType.DIRECTED;
      case DIRECTED:
        return EdgeType.UNDIRECTED;
    }
    throw new IllegalStateException("Unexpected edge type: " + edgeType);
  }

  @Test

						continue
					}
					err = fmt.Errorf("unexpected json type below root :%v", typ)
					r.err = &err
					return
				}

				o, err := obj.Object(&tmpObj)
				if err != nil {
					r.err = &err
					return
				}
				select {
				case <-r.exitReader:
					return
				case r.decoded <- *o:
				}
			default:
				err = fmt.Errorf("unexpected root json type:%v", typ)
				r.err = &err

        ),
      ).assertLogMatch(
        Regex(