diff --git a/test/jakarta/servlet/http/TestHttpServletDoHeadValidWrite0.java b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite0ValidWrite0.java similarity index 76% rename from test/jakarta/servlet/http/TestHttpServletDoHeadValidWrite0.java rename to test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite0ValidWrite0.java index 6f33a5ac7ee3..2eca507ae425 100644 --- a/test/jakarta/servlet/http/TestHttpServletDoHeadValidWrite0.java +++ b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite0ValidWrite0.java @@ -28,7 +28,7 @@ * of an entire test run. */ @RunWith(Parameterized.class) -public class TestHttpServletDoHeadValidWrite0 extends HttpServletDoHeadBaseTest { +public class TestHttpServletDoHeadInvalidWrite0ValidWrite0 extends HttpServletDoHeadBaseTest { @Parameterized.Parameters(name = "{index}: {0} {1} {2} {3} {4} {5} {6} {7} {8}") public static Collection parameters() { @@ -39,13 +39,11 @@ public static Collection parameters() { for (Boolean l : booleans) { for (Integer buf : BUFFERS) { for (Boolean w : booleans) { - for (Integer c1 : COUNTS) { - for (ResetType rt : ResetType.values()) { - for (Boolean f : booleans) { - parameterSets.add(new Object[] { - base[0], base[1], - l, buf, w, c1, rt, Integer.valueOf(0), f }); - } + for (ResetType rt : ResetType.values()) { + for (Boolean f : booleans) { + parameterSets.add(new Object[] { + base[0], base[1], + l, buf, w, Integer.valueOf(0), rt, Integer.valueOf(0), f }); } } } diff --git a/test/jakarta/servlet/http/TestHttpServletDoHeadValidWrite1.java b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite0ValidWrite1.java similarity index 76% rename from test/jakarta/servlet/http/TestHttpServletDoHeadValidWrite1.java rename to test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite0ValidWrite1.java index 24b02570f72c..166f095aa516 100644 --- a/test/jakarta/servlet/http/TestHttpServletDoHeadValidWrite1.java +++ b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite0ValidWrite1.java @@ -28,7 +28,7 @@ * of an entire test run. */ @RunWith(Parameterized.class) -public class TestHttpServletDoHeadValidWrite1 extends HttpServletDoHeadBaseTest { +public class TestHttpServletDoHeadInvalidWrite0ValidWrite1 extends HttpServletDoHeadBaseTest { @Parameterized.Parameters(name = "{index}: {0} {1} {2} {3} {4} {5} {6} {7} {8}") public static Collection parameters() { @@ -39,13 +39,11 @@ public static Collection parameters() { for (Boolean l : booleans) { for (Integer buf : BUFFERS) { for (Boolean w : booleans) { - for (Integer c1 : COUNTS) { - for (ResetType rt : ResetType.values()) { - for (Boolean f : booleans) { - parameterSets.add(new Object[] { - base[0], base[1], - l, buf, w, c1, rt, Integer.valueOf(1), f }); - } + for (ResetType rt : ResetType.values()) { + for (Boolean f : booleans) { + parameterSets.add(new Object[] { + base[0], base[1], + l, buf, w, Integer.valueOf(0), rt, Integer.valueOf(1), f }); } } } diff --git a/test/jakarta/servlet/http/TestHttpServletDoHeadValidWrite511.java b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite0ValidWrite1023.java similarity index 76% rename from test/jakarta/servlet/http/TestHttpServletDoHeadValidWrite511.java rename to test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite0ValidWrite1023.java index 202747283740..b0f2911fcd08 100644 --- a/test/jakarta/servlet/http/TestHttpServletDoHeadValidWrite511.java +++ b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite0ValidWrite1023.java @@ -28,7 +28,7 @@ * of an entire test run. */ @RunWith(Parameterized.class) -public class TestHttpServletDoHeadValidWrite511 extends HttpServletDoHeadBaseTest { +public class TestHttpServletDoHeadInvalidWrite0ValidWrite1023 extends HttpServletDoHeadBaseTest { @Parameterized.Parameters(name = "{index}: {0} {1} {2} {3} {4} {5} {6} {7} {8}") public static Collection parameters() { @@ -39,13 +39,11 @@ public static Collection parameters() { for (Boolean l : booleans) { for (Integer buf : BUFFERS) { for (Boolean w : booleans) { - for (Integer c1 : COUNTS) { - for (ResetType rt : ResetType.values()) { - for (Boolean f : booleans) { - parameterSets.add(new Object[] { - base[0], base[1], - l, buf, w, c1, rt, Integer.valueOf(511), f }); - } + for (ResetType rt : ResetType.values()) { + for (Boolean f : booleans) { + parameterSets.add(new Object[] { + base[0], base[1], + l, buf, w, Integer.valueOf(0), rt, Integer.valueOf(1023), f }); } } } diff --git a/test/jakarta/servlet/http/TestHttpServletDoHeadValidWrite512.java b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite0ValidWrite1024.java similarity index 76% rename from test/jakarta/servlet/http/TestHttpServletDoHeadValidWrite512.java rename to test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite0ValidWrite1024.java index 13ee6c4f9bc2..2bc3b2cb9bf1 100644 --- a/test/jakarta/servlet/http/TestHttpServletDoHeadValidWrite512.java +++ b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite0ValidWrite1024.java @@ -28,7 +28,7 @@ * of an entire test run. */ @RunWith(Parameterized.class) -public class TestHttpServletDoHeadValidWrite512 extends HttpServletDoHeadBaseTest { +public class TestHttpServletDoHeadInvalidWrite0ValidWrite1024 extends HttpServletDoHeadBaseTest { @Parameterized.Parameters(name = "{index}: {0} {1} {2} {3} {4} {5} {6} {7} {8}") public static Collection parameters() { @@ -39,13 +39,11 @@ public static Collection parameters() { for (Boolean l : booleans) { for (Integer buf : BUFFERS) { for (Boolean w : booleans) { - for (Integer c1 : COUNTS) { - for (ResetType rt : ResetType.values()) { - for (Boolean f : booleans) { - parameterSets.add(new Object[] { - base[0], base[1], - l, buf, w, c1, rt, Integer.valueOf(512), f }); - } + for (ResetType rt : ResetType.values()) { + for (Boolean f : booleans) { + parameterSets.add(new Object[] { + base[0], base[1], + l, buf, w, Integer.valueOf(0), rt, Integer.valueOf(1024), f }); } } } diff --git a/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite0ValidWrite1025.java b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite0ValidWrite1025.java new file mode 100644 index 000000000000..c348ae72fe58 --- /dev/null +++ b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite0ValidWrite1025.java @@ -0,0 +1,55 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package jakarta.servlet.http; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +/* + * Split into multiple tests as a single test takes so long it impacts the time + * of an entire test run. + */ +@RunWith(Parameterized.class) +public class TestHttpServletDoHeadInvalidWrite0ValidWrite1025 extends HttpServletDoHeadBaseTest { + + @Parameterized.Parameters(name = "{index}: {0} {1} {2} {3} {4} {5} {6} {7} {8}") + public static Collection parameters() { + Collection baseData = data(); + + List parameterSets = new ArrayList<>(); + for (Object[] base : baseData) { + for (Boolean l : booleans) { + for (Integer buf : BUFFERS) { + for (Boolean w : booleans) { + for (ResetType rt : ResetType.values()) { + for (Boolean f : booleans) { + parameterSets.add(new Object[] { + base[0], base[1], + l, buf, w, Integer.valueOf(0), rt, Integer.valueOf(1025), f }); + } + } + } + } + } + } + return parameterSets; + } +} diff --git a/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite0ValidWrite511.java b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite0ValidWrite511.java new file mode 100644 index 000000000000..ae73637a73de --- /dev/null +++ b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite0ValidWrite511.java @@ -0,0 +1,55 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package jakarta.servlet.http; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +/* + * Split into multiple tests as a single test takes so long it impacts the time + * of an entire test run. + */ +@RunWith(Parameterized.class) +public class TestHttpServletDoHeadInvalidWrite0ValidWrite511 extends HttpServletDoHeadBaseTest { + + @Parameterized.Parameters(name = "{index}: {0} {1} {2} {3} {4} {5} {6} {7} {8}") + public static Collection parameters() { + Collection baseData = data(); + + List parameterSets = new ArrayList<>(); + for (Object[] base : baseData) { + for (Boolean l : booleans) { + for (Integer buf : BUFFERS) { + for (Boolean w : booleans) { + for (ResetType rt : ResetType.values()) { + for (Boolean f : booleans) { + parameterSets.add(new Object[] { + base[0], base[1], + l, buf, w, Integer.valueOf(0), rt, Integer.valueOf(511), f }); + } + } + } + } + } + } + return parameterSets; + } +} diff --git a/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite0ValidWrite512.java b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite0ValidWrite512.java new file mode 100644 index 000000000000..cd32dbae0aec --- /dev/null +++ b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite0ValidWrite512.java @@ -0,0 +1,55 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package jakarta.servlet.http; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +/* + * Split into multiple tests as a single test takes so long it impacts the time + * of an entire test run. + */ +@RunWith(Parameterized.class) +public class TestHttpServletDoHeadInvalidWrite0ValidWrite512 extends HttpServletDoHeadBaseTest { + + @Parameterized.Parameters(name = "{index}: {0} {1} {2} {3} {4} {5} {6} {7} {8}") + public static Collection parameters() { + Collection baseData = data(); + + List parameterSets = new ArrayList<>(); + for (Object[] base : baseData) { + for (Boolean l : booleans) { + for (Integer buf : BUFFERS) { + for (Boolean w : booleans) { + for (ResetType rt : ResetType.values()) { + for (Boolean f : booleans) { + parameterSets.add(new Object[] { + base[0], base[1], + l, buf, w, Integer.valueOf(0), rt, Integer.valueOf(512), f }); + } + } + } + } + } + } + return parameterSets; + } +} diff --git a/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite0ValidWrite513.java b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite0ValidWrite513.java new file mode 100644 index 000000000000..4e61d9bd00e6 --- /dev/null +++ b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite0ValidWrite513.java @@ -0,0 +1,55 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package jakarta.servlet.http; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +/* + * Split into multiple tests as a single test takes so long it impacts the time + * of an entire test run. + */ +@RunWith(Parameterized.class) +public class TestHttpServletDoHeadInvalidWrite0ValidWrite513 extends HttpServletDoHeadBaseTest { + + @Parameterized.Parameters(name = "{index}: {0} {1} {2} {3} {4} {5} {6} {7} {8}") + public static Collection parameters() { + Collection baseData = data(); + + List parameterSets = new ArrayList<>(); + for (Object[] base : baseData) { + for (Boolean l : booleans) { + for (Integer buf : BUFFERS) { + for (Boolean w : booleans) { + for (ResetType rt : ResetType.values()) { + for (Boolean f : booleans) { + parameterSets.add(new Object[] { + base[0], base[1], + l, buf, w, Integer.valueOf(0), rt, Integer.valueOf(513), f }); + } + } + } + } + } + } + return parameterSets; + } +} diff --git a/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1023ValidWrite0.java b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1023ValidWrite0.java new file mode 100644 index 000000000000..3a5d2a658041 --- /dev/null +++ b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1023ValidWrite0.java @@ -0,0 +1,55 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package jakarta.servlet.http; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +/* + * Split into multiple tests as a single test takes so long it impacts the time + * of an entire test run. + */ +@RunWith(Parameterized.class) +public class TestHttpServletDoHeadInvalidWrite1023ValidWrite0 extends HttpServletDoHeadBaseTest { + + @Parameterized.Parameters(name = "{index}: {0} {1} {2} {3} {4} {5} {6} {7} {8}") + public static Collection parameters() { + Collection baseData = data(); + + List parameterSets = new ArrayList<>(); + for (Object[] base : baseData) { + for (Boolean l : booleans) { + for (Integer buf : BUFFERS) { + for (Boolean w : booleans) { + for (ResetType rt : ResetType.values()) { + for (Boolean f : booleans) { + parameterSets.add(new Object[] { + base[0], base[1], + l, buf, w, Integer.valueOf(1023), rt, Integer.valueOf(0), f }); + } + } + } + } + } + } + return parameterSets; + } +} diff --git a/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1023ValidWrite1.java b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1023ValidWrite1.java new file mode 100644 index 000000000000..77c3b78551b0 --- /dev/null +++ b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1023ValidWrite1.java @@ -0,0 +1,55 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package jakarta.servlet.http; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +/* + * Split into multiple tests as a single test takes so long it impacts the time + * of an entire test run. + */ +@RunWith(Parameterized.class) +public class TestHttpServletDoHeadInvalidWrite1023ValidWrite1 extends HttpServletDoHeadBaseTest { + + @Parameterized.Parameters(name = "{index}: {0} {1} {2} {3} {4} {5} {6} {7} {8}") + public static Collection parameters() { + Collection baseData = data(); + + List parameterSets = new ArrayList<>(); + for (Object[] base : baseData) { + for (Boolean l : booleans) { + for (Integer buf : BUFFERS) { + for (Boolean w : booleans) { + for (ResetType rt : ResetType.values()) { + for (Boolean f : booleans) { + parameterSets.add(new Object[] { + base[0], base[1], + l, buf, w, Integer.valueOf(1023), rt, Integer.valueOf(1), f }); + } + } + } + } + } + } + return parameterSets; + } +} diff --git a/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1023ValidWrite1023.java b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1023ValidWrite1023.java new file mode 100644 index 000000000000..7891dac2ff1b --- /dev/null +++ b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1023ValidWrite1023.java @@ -0,0 +1,55 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package jakarta.servlet.http; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +/* + * Split into multiple tests as a single test takes so long it impacts the time + * of an entire test run. + */ +@RunWith(Parameterized.class) +public class TestHttpServletDoHeadInvalidWrite1023ValidWrite1023 extends HttpServletDoHeadBaseTest { + + @Parameterized.Parameters(name = "{index}: {0} {1} {2} {3} {4} {5} {6} {7} {8}") + public static Collection parameters() { + Collection baseData = data(); + + List parameterSets = new ArrayList<>(); + for (Object[] base : baseData) { + for (Boolean l : booleans) { + for (Integer buf : BUFFERS) { + for (Boolean w : booleans) { + for (ResetType rt : ResetType.values()) { + for (Boolean f : booleans) { + parameterSets.add(new Object[] { + base[0], base[1], + l, buf, w, Integer.valueOf(1023), rt, Integer.valueOf(1023), f }); + } + } + } + } + } + } + return parameterSets; + } +} diff --git a/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1023ValidWrite1024.java b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1023ValidWrite1024.java new file mode 100644 index 000000000000..fbef824a2aea --- /dev/null +++ b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1023ValidWrite1024.java @@ -0,0 +1,55 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package jakarta.servlet.http; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +/* + * Split into multiple tests as a single test takes so long it impacts the time + * of an entire test run. + */ +@RunWith(Parameterized.class) +public class TestHttpServletDoHeadInvalidWrite1023ValidWrite1024 extends HttpServletDoHeadBaseTest { + + @Parameterized.Parameters(name = "{index}: {0} {1} {2} {3} {4} {5} {6} {7} {8}") + public static Collection parameters() { + Collection baseData = data(); + + List parameterSets = new ArrayList<>(); + for (Object[] base : baseData) { + for (Boolean l : booleans) { + for (Integer buf : BUFFERS) { + for (Boolean w : booleans) { + for (ResetType rt : ResetType.values()) { + for (Boolean f : booleans) { + parameterSets.add(new Object[] { + base[0], base[1], + l, buf, w, Integer.valueOf(1023), rt, Integer.valueOf(1024), f }); + } + } + } + } + } + } + return parameterSets; + } +} diff --git a/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1023ValidWrite1025.java b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1023ValidWrite1025.java new file mode 100644 index 000000000000..1feb216b8c70 --- /dev/null +++ b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1023ValidWrite1025.java @@ -0,0 +1,55 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package jakarta.servlet.http; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +/* + * Split into multiple tests as a single test takes so long it impacts the time + * of an entire test run. + */ +@RunWith(Parameterized.class) +public class TestHttpServletDoHeadInvalidWrite1023ValidWrite1025 extends HttpServletDoHeadBaseTest { + + @Parameterized.Parameters(name = "{index}: {0} {1} {2} {3} {4} {5} {6} {7} {8}") + public static Collection parameters() { + Collection baseData = data(); + + List parameterSets = new ArrayList<>(); + for (Object[] base : baseData) { + for (Boolean l : booleans) { + for (Integer buf : BUFFERS) { + for (Boolean w : booleans) { + for (ResetType rt : ResetType.values()) { + for (Boolean f : booleans) { + parameterSets.add(new Object[] { + base[0], base[1], + l, buf, w, Integer.valueOf(1023), rt, Integer.valueOf(1025), f }); + } + } + } + } + } + } + return parameterSets; + } +} diff --git a/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1023ValidWrite511.java b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1023ValidWrite511.java new file mode 100644 index 000000000000..6e0f1f4b6cb3 --- /dev/null +++ b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1023ValidWrite511.java @@ -0,0 +1,55 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package jakarta.servlet.http; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +/* + * Split into multiple tests as a single test takes so long it impacts the time + * of an entire test run. + */ +@RunWith(Parameterized.class) +public class TestHttpServletDoHeadInvalidWrite1023ValidWrite511 extends HttpServletDoHeadBaseTest { + + @Parameterized.Parameters(name = "{index}: {0} {1} {2} {3} {4} {5} {6} {7} {8}") + public static Collection parameters() { + Collection baseData = data(); + + List parameterSets = new ArrayList<>(); + for (Object[] base : baseData) { + for (Boolean l : booleans) { + for (Integer buf : BUFFERS) { + for (Boolean w : booleans) { + for (ResetType rt : ResetType.values()) { + for (Boolean f : booleans) { + parameterSets.add(new Object[] { + base[0], base[1], + l, buf, w, Integer.valueOf(1023), rt, Integer.valueOf(511), f }); + } + } + } + } + } + } + return parameterSets; + } +} diff --git a/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1023ValidWrite512.java b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1023ValidWrite512.java new file mode 100644 index 000000000000..4d2d50f63abf --- /dev/null +++ b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1023ValidWrite512.java @@ -0,0 +1,55 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package jakarta.servlet.http; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +/* + * Split into multiple tests as a single test takes so long it impacts the time + * of an entire test run. + */ +@RunWith(Parameterized.class) +public class TestHttpServletDoHeadInvalidWrite1023ValidWrite512 extends HttpServletDoHeadBaseTest { + + @Parameterized.Parameters(name = "{index}: {0} {1} {2} {3} {4} {5} {6} {7} {8}") + public static Collection parameters() { + Collection baseData = data(); + + List parameterSets = new ArrayList<>(); + for (Object[] base : baseData) { + for (Boolean l : booleans) { + for (Integer buf : BUFFERS) { + for (Boolean w : booleans) { + for (ResetType rt : ResetType.values()) { + for (Boolean f : booleans) { + parameterSets.add(new Object[] { + base[0], base[1], + l, buf, w, Integer.valueOf(1023), rt, Integer.valueOf(512), f }); + } + } + } + } + } + } + return parameterSets; + } +} diff --git a/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1023ValidWrite513.java b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1023ValidWrite513.java new file mode 100644 index 000000000000..7243972a38ec --- /dev/null +++ b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1023ValidWrite513.java @@ -0,0 +1,55 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package jakarta.servlet.http; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +/* + * Split into multiple tests as a single test takes so long it impacts the time + * of an entire test run. + */ +@RunWith(Parameterized.class) +public class TestHttpServletDoHeadInvalidWrite1023ValidWrite513 extends HttpServletDoHeadBaseTest { + + @Parameterized.Parameters(name = "{index}: {0} {1} {2} {3} {4} {5} {6} {7} {8}") + public static Collection parameters() { + Collection baseData = data(); + + List parameterSets = new ArrayList<>(); + for (Object[] base : baseData) { + for (Boolean l : booleans) { + for (Integer buf : BUFFERS) { + for (Boolean w : booleans) { + for (ResetType rt : ResetType.values()) { + for (Boolean f : booleans) { + parameterSets.add(new Object[] { + base[0], base[1], + l, buf, w, Integer.valueOf(1023), rt, Integer.valueOf(513), f }); + } + } + } + } + } + } + return parameterSets; + } +} diff --git a/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1024ValidWrite0.java b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1024ValidWrite0.java new file mode 100644 index 000000000000..231f2827d5e3 --- /dev/null +++ b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1024ValidWrite0.java @@ -0,0 +1,55 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package jakarta.servlet.http; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +/* + * Split into multiple tests as a single test takes so long it impacts the time + * of an entire test run. + */ +@RunWith(Parameterized.class) +public class TestHttpServletDoHeadInvalidWrite1024ValidWrite0 extends HttpServletDoHeadBaseTest { + + @Parameterized.Parameters(name = "{index}: {0} {1} {2} {3} {4} {5} {6} {7} {8}") + public static Collection parameters() { + Collection baseData = data(); + + List parameterSets = new ArrayList<>(); + for (Object[] base : baseData) { + for (Boolean l : booleans) { + for (Integer buf : BUFFERS) { + for (Boolean w : booleans) { + for (ResetType rt : ResetType.values()) { + for (Boolean f : booleans) { + parameterSets.add(new Object[] { + base[0], base[1], + l, buf, w, Integer.valueOf(1024), rt, Integer.valueOf(0), f }); + } + } + } + } + } + } + return parameterSets; + } +} diff --git a/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1024ValidWrite1.java b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1024ValidWrite1.java new file mode 100644 index 000000000000..24432a13755a --- /dev/null +++ b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1024ValidWrite1.java @@ -0,0 +1,55 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package jakarta.servlet.http; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +/* + * Split into multiple tests as a single test takes so long it impacts the time + * of an entire test run. + */ +@RunWith(Parameterized.class) +public class TestHttpServletDoHeadInvalidWrite1024ValidWrite1 extends HttpServletDoHeadBaseTest { + + @Parameterized.Parameters(name = "{index}: {0} {1} {2} {3} {4} {5} {6} {7} {8}") + public static Collection parameters() { + Collection baseData = data(); + + List parameterSets = new ArrayList<>(); + for (Object[] base : baseData) { + for (Boolean l : booleans) { + for (Integer buf : BUFFERS) { + for (Boolean w : booleans) { + for (ResetType rt : ResetType.values()) { + for (Boolean f : booleans) { + parameterSets.add(new Object[] { + base[0], base[1], + l, buf, w, Integer.valueOf(1024), rt, Integer.valueOf(1), f }); + } + } + } + } + } + } + return parameterSets; + } +} diff --git a/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1024ValidWrite1023.java b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1024ValidWrite1023.java new file mode 100644 index 000000000000..af8136a4701b --- /dev/null +++ b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1024ValidWrite1023.java @@ -0,0 +1,55 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package jakarta.servlet.http; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +/* + * Split into multiple tests as a single test takes so long it impacts the time + * of an entire test run. + */ +@RunWith(Parameterized.class) +public class TestHttpServletDoHeadInvalidWrite1024ValidWrite1023 extends HttpServletDoHeadBaseTest { + + @Parameterized.Parameters(name = "{index}: {0} {1} {2} {3} {4} {5} {6} {7} {8}") + public static Collection parameters() { + Collection baseData = data(); + + List parameterSets = new ArrayList<>(); + for (Object[] base : baseData) { + for (Boolean l : booleans) { + for (Integer buf : BUFFERS) { + for (Boolean w : booleans) { + for (ResetType rt : ResetType.values()) { + for (Boolean f : booleans) { + parameterSets.add(new Object[] { + base[0], base[1], + l, buf, w, Integer.valueOf(1024), rt, Integer.valueOf(1023), f }); + } + } + } + } + } + } + return parameterSets; + } +} diff --git a/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1024ValidWrite1024.java b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1024ValidWrite1024.java new file mode 100644 index 000000000000..c4c58a6188e4 --- /dev/null +++ b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1024ValidWrite1024.java @@ -0,0 +1,55 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package jakarta.servlet.http; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +/* + * Split into multiple tests as a single test takes so long it impacts the time + * of an entire test run. + */ +@RunWith(Parameterized.class) +public class TestHttpServletDoHeadInvalidWrite1024ValidWrite1024 extends HttpServletDoHeadBaseTest { + + @Parameterized.Parameters(name = "{index}: {0} {1} {2} {3} {4} {5} {6} {7} {8}") + public static Collection parameters() { + Collection baseData = data(); + + List parameterSets = new ArrayList<>(); + for (Object[] base : baseData) { + for (Boolean l : booleans) { + for (Integer buf : BUFFERS) { + for (Boolean w : booleans) { + for (ResetType rt : ResetType.values()) { + for (Boolean f : booleans) { + parameterSets.add(new Object[] { + base[0], base[1], + l, buf, w, Integer.valueOf(1024), rt, Integer.valueOf(1024), f }); + } + } + } + } + } + } + return parameterSets; + } +} diff --git a/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1024ValidWrite1025.java b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1024ValidWrite1025.java new file mode 100644 index 000000000000..13961b3ed94a --- /dev/null +++ b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1024ValidWrite1025.java @@ -0,0 +1,55 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package jakarta.servlet.http; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +/* + * Split into multiple tests as a single test takes so long it impacts the time + * of an entire test run. + */ +@RunWith(Parameterized.class) +public class TestHttpServletDoHeadInvalidWrite1024ValidWrite1025 extends HttpServletDoHeadBaseTest { + + @Parameterized.Parameters(name = "{index}: {0} {1} {2} {3} {4} {5} {6} {7} {8}") + public static Collection parameters() { + Collection baseData = data(); + + List parameterSets = new ArrayList<>(); + for (Object[] base : baseData) { + for (Boolean l : booleans) { + for (Integer buf : BUFFERS) { + for (Boolean w : booleans) { + for (ResetType rt : ResetType.values()) { + for (Boolean f : booleans) { + parameterSets.add(new Object[] { + base[0], base[1], + l, buf, w, Integer.valueOf(1024), rt, Integer.valueOf(1025), f }); + } + } + } + } + } + } + return parameterSets; + } +} diff --git a/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1024ValidWrite511.java b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1024ValidWrite511.java new file mode 100644 index 000000000000..0c636711a0e0 --- /dev/null +++ b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1024ValidWrite511.java @@ -0,0 +1,55 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package jakarta.servlet.http; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +/* + * Split into multiple tests as a single test takes so long it impacts the time + * of an entire test run. + */ +@RunWith(Parameterized.class) +public class TestHttpServletDoHeadInvalidWrite1024ValidWrite511 extends HttpServletDoHeadBaseTest { + + @Parameterized.Parameters(name = "{index}: {0} {1} {2} {3} {4} {5} {6} {7} {8}") + public static Collection parameters() { + Collection baseData = data(); + + List parameterSets = new ArrayList<>(); + for (Object[] base : baseData) { + for (Boolean l : booleans) { + for (Integer buf : BUFFERS) { + for (Boolean w : booleans) { + for (ResetType rt : ResetType.values()) { + for (Boolean f : booleans) { + parameterSets.add(new Object[] { + base[0], base[1], + l, buf, w, Integer.valueOf(1024), rt, Integer.valueOf(511), f }); + } + } + } + } + } + } + return parameterSets; + } +} diff --git a/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1024ValidWrite512.java b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1024ValidWrite512.java new file mode 100644 index 000000000000..6a9f811c39eb --- /dev/null +++ b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1024ValidWrite512.java @@ -0,0 +1,55 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package jakarta.servlet.http; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +/* + * Split into multiple tests as a single test takes so long it impacts the time + * of an entire test run. + */ +@RunWith(Parameterized.class) +public class TestHttpServletDoHeadInvalidWrite1024ValidWrite512 extends HttpServletDoHeadBaseTest { + + @Parameterized.Parameters(name = "{index}: {0} {1} {2} {3} {4} {5} {6} {7} {8}") + public static Collection parameters() { + Collection baseData = data(); + + List parameterSets = new ArrayList<>(); + for (Object[] base : baseData) { + for (Boolean l : booleans) { + for (Integer buf : BUFFERS) { + for (Boolean w : booleans) { + for (ResetType rt : ResetType.values()) { + for (Boolean f : booleans) { + parameterSets.add(new Object[] { + base[0], base[1], + l, buf, w, Integer.valueOf(1024), rt, Integer.valueOf(512), f }); + } + } + } + } + } + } + return parameterSets; + } +} diff --git a/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1024ValidWrite513.java b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1024ValidWrite513.java new file mode 100644 index 000000000000..b175dc9409c6 --- /dev/null +++ b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1024ValidWrite513.java @@ -0,0 +1,55 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package jakarta.servlet.http; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +/* + * Split into multiple tests as a single test takes so long it impacts the time + * of an entire test run. + */ +@RunWith(Parameterized.class) +public class TestHttpServletDoHeadInvalidWrite1024ValidWrite513 extends HttpServletDoHeadBaseTest { + + @Parameterized.Parameters(name = "{index}: {0} {1} {2} {3} {4} {5} {6} {7} {8}") + public static Collection parameters() { + Collection baseData = data(); + + List parameterSets = new ArrayList<>(); + for (Object[] base : baseData) { + for (Boolean l : booleans) { + for (Integer buf : BUFFERS) { + for (Boolean w : booleans) { + for (ResetType rt : ResetType.values()) { + for (Boolean f : booleans) { + parameterSets.add(new Object[] { + base[0], base[1], + l, buf, w, Integer.valueOf(1024), rt, Integer.valueOf(513), f }); + } + } + } + } + } + } + return parameterSets; + } +} diff --git a/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1025ValidWrite0.java b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1025ValidWrite0.java new file mode 100644 index 000000000000..eaa22403ea79 --- /dev/null +++ b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1025ValidWrite0.java @@ -0,0 +1,55 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package jakarta.servlet.http; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +/* + * Split into multiple tests as a single test takes so long it impacts the time + * of an entire test run. + */ +@RunWith(Parameterized.class) +public class TestHttpServletDoHeadInvalidWrite1025ValidWrite0 extends HttpServletDoHeadBaseTest { + + @Parameterized.Parameters(name = "{index}: {0} {1} {2} {3} {4} {5} {6} {7} {8}") + public static Collection parameters() { + Collection baseData = data(); + + List parameterSets = new ArrayList<>(); + for (Object[] base : baseData) { + for (Boolean l : booleans) { + for (Integer buf : BUFFERS) { + for (Boolean w : booleans) { + for (ResetType rt : ResetType.values()) { + for (Boolean f : booleans) { + parameterSets.add(new Object[] { + base[0], base[1], + l, buf, w, Integer.valueOf(1025), rt, Integer.valueOf(0), f }); + } + } + } + } + } + } + return parameterSets; + } +} diff --git a/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1025ValidWrite1.java b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1025ValidWrite1.java new file mode 100644 index 000000000000..e4ee5fca8e17 --- /dev/null +++ b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1025ValidWrite1.java @@ -0,0 +1,55 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package jakarta.servlet.http; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +/* + * Split into multiple tests as a single test takes so long it impacts the time + * of an entire test run. + */ +@RunWith(Parameterized.class) +public class TestHttpServletDoHeadInvalidWrite1025ValidWrite1 extends HttpServletDoHeadBaseTest { + + @Parameterized.Parameters(name = "{index}: {0} {1} {2} {3} {4} {5} {6} {7} {8}") + public static Collection parameters() { + Collection baseData = data(); + + List parameterSets = new ArrayList<>(); + for (Object[] base : baseData) { + for (Boolean l : booleans) { + for (Integer buf : BUFFERS) { + for (Boolean w : booleans) { + for (ResetType rt : ResetType.values()) { + for (Boolean f : booleans) { + parameterSets.add(new Object[] { + base[0], base[1], + l, buf, w, Integer.valueOf(1025), rt, Integer.valueOf(1), f }); + } + } + } + } + } + } + return parameterSets; + } +} diff --git a/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1025ValidWrite1023.java b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1025ValidWrite1023.java new file mode 100644 index 000000000000..2647f7268a8e --- /dev/null +++ b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1025ValidWrite1023.java @@ -0,0 +1,55 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package jakarta.servlet.http; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +/* + * Split into multiple tests as a single test takes so long it impacts the time + * of an entire test run. + */ +@RunWith(Parameterized.class) +public class TestHttpServletDoHeadInvalidWrite1025ValidWrite1023 extends HttpServletDoHeadBaseTest { + + @Parameterized.Parameters(name = "{index}: {0} {1} {2} {3} {4} {5} {6} {7} {8}") + public static Collection parameters() { + Collection baseData = data(); + + List parameterSets = new ArrayList<>(); + for (Object[] base : baseData) { + for (Boolean l : booleans) { + for (Integer buf : BUFFERS) { + for (Boolean w : booleans) { + for (ResetType rt : ResetType.values()) { + for (Boolean f : booleans) { + parameterSets.add(new Object[] { + base[0], base[1], + l, buf, w, Integer.valueOf(1025), rt, Integer.valueOf(1023), f }); + } + } + } + } + } + } + return parameterSets; + } +} diff --git a/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1025ValidWrite1024.java b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1025ValidWrite1024.java new file mode 100644 index 000000000000..42caab56b513 --- /dev/null +++ b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1025ValidWrite1024.java @@ -0,0 +1,55 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package jakarta.servlet.http; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +/* + * Split into multiple tests as a single test takes so long it impacts the time + * of an entire test run. + */ +@RunWith(Parameterized.class) +public class TestHttpServletDoHeadInvalidWrite1025ValidWrite1024 extends HttpServletDoHeadBaseTest { + + @Parameterized.Parameters(name = "{index}: {0} {1} {2} {3} {4} {5} {6} {7} {8}") + public static Collection parameters() { + Collection baseData = data(); + + List parameterSets = new ArrayList<>(); + for (Object[] base : baseData) { + for (Boolean l : booleans) { + for (Integer buf : BUFFERS) { + for (Boolean w : booleans) { + for (ResetType rt : ResetType.values()) { + for (Boolean f : booleans) { + parameterSets.add(new Object[] { + base[0], base[1], + l, buf, w, Integer.valueOf(1025), rt, Integer.valueOf(1024), f }); + } + } + } + } + } + } + return parameterSets; + } +} diff --git a/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1025ValidWrite1025.java b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1025ValidWrite1025.java new file mode 100644 index 000000000000..1685b3c384dd --- /dev/null +++ b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1025ValidWrite1025.java @@ -0,0 +1,55 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package jakarta.servlet.http; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +/* + * Split into multiple tests as a single test takes so long it impacts the time + * of an entire test run. + */ +@RunWith(Parameterized.class) +public class TestHttpServletDoHeadInvalidWrite1025ValidWrite1025 extends HttpServletDoHeadBaseTest { + + @Parameterized.Parameters(name = "{index}: {0} {1} {2} {3} {4} {5} {6} {7} {8}") + public static Collection parameters() { + Collection baseData = data(); + + List parameterSets = new ArrayList<>(); + for (Object[] base : baseData) { + for (Boolean l : booleans) { + for (Integer buf : BUFFERS) { + for (Boolean w : booleans) { + for (ResetType rt : ResetType.values()) { + for (Boolean f : booleans) { + parameterSets.add(new Object[] { + base[0], base[1], + l, buf, w, Integer.valueOf(1025), rt, Integer.valueOf(1025), f }); + } + } + } + } + } + } + return parameterSets; + } +} diff --git a/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1025ValidWrite511.java b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1025ValidWrite511.java new file mode 100644 index 000000000000..01ef3243cb99 --- /dev/null +++ b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1025ValidWrite511.java @@ -0,0 +1,55 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package jakarta.servlet.http; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +/* + * Split into multiple tests as a single test takes so long it impacts the time + * of an entire test run. + */ +@RunWith(Parameterized.class) +public class TestHttpServletDoHeadInvalidWrite1025ValidWrite511 extends HttpServletDoHeadBaseTest { + + @Parameterized.Parameters(name = "{index}: {0} {1} {2} {3} {4} {5} {6} {7} {8}") + public static Collection parameters() { + Collection baseData = data(); + + List parameterSets = new ArrayList<>(); + for (Object[] base : baseData) { + for (Boolean l : booleans) { + for (Integer buf : BUFFERS) { + for (Boolean w : booleans) { + for (ResetType rt : ResetType.values()) { + for (Boolean f : booleans) { + parameterSets.add(new Object[] { + base[0], base[1], + l, buf, w, Integer.valueOf(1025), rt, Integer.valueOf(511), f }); + } + } + } + } + } + } + return parameterSets; + } +} diff --git a/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1025ValidWrite512.java b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1025ValidWrite512.java new file mode 100644 index 000000000000..887ab22f2e4a --- /dev/null +++ b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1025ValidWrite512.java @@ -0,0 +1,55 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package jakarta.servlet.http; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +/* + * Split into multiple tests as a single test takes so long it impacts the time + * of an entire test run. + */ +@RunWith(Parameterized.class) +public class TestHttpServletDoHeadInvalidWrite1025ValidWrite512 extends HttpServletDoHeadBaseTest { + + @Parameterized.Parameters(name = "{index}: {0} {1} {2} {3} {4} {5} {6} {7} {8}") + public static Collection parameters() { + Collection baseData = data(); + + List parameterSets = new ArrayList<>(); + for (Object[] base : baseData) { + for (Boolean l : booleans) { + for (Integer buf : BUFFERS) { + for (Boolean w : booleans) { + for (ResetType rt : ResetType.values()) { + for (Boolean f : booleans) { + parameterSets.add(new Object[] { + base[0], base[1], + l, buf, w, Integer.valueOf(1025), rt, Integer.valueOf(512), f }); + } + } + } + } + } + } + return parameterSets; + } +} diff --git a/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1025ValidWrite513.java b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1025ValidWrite513.java new file mode 100644 index 000000000000..1d936e9830be --- /dev/null +++ b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1025ValidWrite513.java @@ -0,0 +1,55 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package jakarta.servlet.http; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +/* + * Split into multiple tests as a single test takes so long it impacts the time + * of an entire test run. + */ +@RunWith(Parameterized.class) +public class TestHttpServletDoHeadInvalidWrite1025ValidWrite513 extends HttpServletDoHeadBaseTest { + + @Parameterized.Parameters(name = "{index}: {0} {1} {2} {3} {4} {5} {6} {7} {8}") + public static Collection parameters() { + Collection baseData = data(); + + List parameterSets = new ArrayList<>(); + for (Object[] base : baseData) { + for (Boolean l : booleans) { + for (Integer buf : BUFFERS) { + for (Boolean w : booleans) { + for (ResetType rt : ResetType.values()) { + for (Boolean f : booleans) { + parameterSets.add(new Object[] { + base[0], base[1], + l, buf, w, Integer.valueOf(1025), rt, Integer.valueOf(513), f }); + } + } + } + } + } + } + return parameterSets; + } +} diff --git a/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1ValidWrite0.java b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1ValidWrite0.java new file mode 100644 index 000000000000..d4636055d273 --- /dev/null +++ b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1ValidWrite0.java @@ -0,0 +1,55 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package jakarta.servlet.http; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +/* + * Split into multiple tests as a single test takes so long it impacts the time + * of an entire test run. + */ +@RunWith(Parameterized.class) +public class TestHttpServletDoHeadInvalidWrite1ValidWrite0 extends HttpServletDoHeadBaseTest { + + @Parameterized.Parameters(name = "{index}: {0} {1} {2} {3} {4} {5} {6} {7} {8}") + public static Collection parameters() { + Collection baseData = data(); + + List parameterSets = new ArrayList<>(); + for (Object[] base : baseData) { + for (Boolean l : booleans) { + for (Integer buf : BUFFERS) { + for (Boolean w : booleans) { + for (ResetType rt : ResetType.values()) { + for (Boolean f : booleans) { + parameterSets.add(new Object[] { + base[0], base[1], + l, buf, w, Integer.valueOf(1), rt, Integer.valueOf(0), f }); + } + } + } + } + } + } + return parameterSets; + } +} diff --git a/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1ValidWrite1.java b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1ValidWrite1.java new file mode 100644 index 000000000000..0388fd04c251 --- /dev/null +++ b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1ValidWrite1.java @@ -0,0 +1,55 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package jakarta.servlet.http; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +/* + * Split into multiple tests as a single test takes so long it impacts the time + * of an entire test run. + */ +@RunWith(Parameterized.class) +public class TestHttpServletDoHeadInvalidWrite1ValidWrite1 extends HttpServletDoHeadBaseTest { + + @Parameterized.Parameters(name = "{index}: {0} {1} {2} {3} {4} {5} {6} {7} {8}") + public static Collection parameters() { + Collection baseData = data(); + + List parameterSets = new ArrayList<>(); + for (Object[] base : baseData) { + for (Boolean l : booleans) { + for (Integer buf : BUFFERS) { + for (Boolean w : booleans) { + for (ResetType rt : ResetType.values()) { + for (Boolean f : booleans) { + parameterSets.add(new Object[] { + base[0], base[1], + l, buf, w, Integer.valueOf(1), rt, Integer.valueOf(1), f }); + } + } + } + } + } + } + return parameterSets; + } +} diff --git a/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1ValidWrite1023.java b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1ValidWrite1023.java new file mode 100644 index 000000000000..479ac0d5e242 --- /dev/null +++ b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1ValidWrite1023.java @@ -0,0 +1,55 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package jakarta.servlet.http; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +/* + * Split into multiple tests as a single test takes so long it impacts the time + * of an entire test run. + */ +@RunWith(Parameterized.class) +public class TestHttpServletDoHeadInvalidWrite1ValidWrite1023 extends HttpServletDoHeadBaseTest { + + @Parameterized.Parameters(name = "{index}: {0} {1} {2} {3} {4} {5} {6} {7} {8}") + public static Collection parameters() { + Collection baseData = data(); + + List parameterSets = new ArrayList<>(); + for (Object[] base : baseData) { + for (Boolean l : booleans) { + for (Integer buf : BUFFERS) { + for (Boolean w : booleans) { + for (ResetType rt : ResetType.values()) { + for (Boolean f : booleans) { + parameterSets.add(new Object[] { + base[0], base[1], + l, buf, w, Integer.valueOf(1), rt, Integer.valueOf(1023), f }); + } + } + } + } + } + } + return parameterSets; + } +} diff --git a/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1ValidWrite1024.java b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1ValidWrite1024.java new file mode 100644 index 000000000000..a2b440192d70 --- /dev/null +++ b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1ValidWrite1024.java @@ -0,0 +1,55 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package jakarta.servlet.http; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +/* + * Split into multiple tests as a single test takes so long it impacts the time + * of an entire test run. + */ +@RunWith(Parameterized.class) +public class TestHttpServletDoHeadInvalidWrite1ValidWrite1024 extends HttpServletDoHeadBaseTest { + + @Parameterized.Parameters(name = "{index}: {0} {1} {2} {3} {4} {5} {6} {7} {8}") + public static Collection parameters() { + Collection baseData = data(); + + List parameterSets = new ArrayList<>(); + for (Object[] base : baseData) { + for (Boolean l : booleans) { + for (Integer buf : BUFFERS) { + for (Boolean w : booleans) { + for (ResetType rt : ResetType.values()) { + for (Boolean f : booleans) { + parameterSets.add(new Object[] { + base[0], base[1], + l, buf, w, Integer.valueOf(1), rt, Integer.valueOf(1024), f }); + } + } + } + } + } + } + return parameterSets; + } +} diff --git a/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1ValidWrite1025.java b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1ValidWrite1025.java new file mode 100644 index 000000000000..39fa978f9588 --- /dev/null +++ b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1ValidWrite1025.java @@ -0,0 +1,55 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package jakarta.servlet.http; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +/* + * Split into multiple tests as a single test takes so long it impacts the time + * of an entire test run. + */ +@RunWith(Parameterized.class) +public class TestHttpServletDoHeadInvalidWrite1ValidWrite1025 extends HttpServletDoHeadBaseTest { + + @Parameterized.Parameters(name = "{index}: {0} {1} {2} {3} {4} {5} {6} {7} {8}") + public static Collection parameters() { + Collection baseData = data(); + + List parameterSets = new ArrayList<>(); + for (Object[] base : baseData) { + for (Boolean l : booleans) { + for (Integer buf : BUFFERS) { + for (Boolean w : booleans) { + for (ResetType rt : ResetType.values()) { + for (Boolean f : booleans) { + parameterSets.add(new Object[] { + base[0], base[1], + l, buf, w, Integer.valueOf(1), rt, Integer.valueOf(1025), f }); + } + } + } + } + } + } + return parameterSets; + } +} diff --git a/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1ValidWrite511.java b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1ValidWrite511.java new file mode 100644 index 000000000000..3390e10d8678 --- /dev/null +++ b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1ValidWrite511.java @@ -0,0 +1,55 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package jakarta.servlet.http; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +/* + * Split into multiple tests as a single test takes so long it impacts the time + * of an entire test run. + */ +@RunWith(Parameterized.class) +public class TestHttpServletDoHeadInvalidWrite1ValidWrite511 extends HttpServletDoHeadBaseTest { + + @Parameterized.Parameters(name = "{index}: {0} {1} {2} {3} {4} {5} {6} {7} {8}") + public static Collection parameters() { + Collection baseData = data(); + + List parameterSets = new ArrayList<>(); + for (Object[] base : baseData) { + for (Boolean l : booleans) { + for (Integer buf : BUFFERS) { + for (Boolean w : booleans) { + for (ResetType rt : ResetType.values()) { + for (Boolean f : booleans) { + parameterSets.add(new Object[] { + base[0], base[1], + l, buf, w, Integer.valueOf(1), rt, Integer.valueOf(511), f }); + } + } + } + } + } + } + return parameterSets; + } +} diff --git a/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1ValidWrite512.java b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1ValidWrite512.java new file mode 100644 index 000000000000..a6a4414bbfed --- /dev/null +++ b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1ValidWrite512.java @@ -0,0 +1,55 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package jakarta.servlet.http; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +/* + * Split into multiple tests as a single test takes so long it impacts the time + * of an entire test run. + */ +@RunWith(Parameterized.class) +public class TestHttpServletDoHeadInvalidWrite1ValidWrite512 extends HttpServletDoHeadBaseTest { + + @Parameterized.Parameters(name = "{index}: {0} {1} {2} {3} {4} {5} {6} {7} {8}") + public static Collection parameters() { + Collection baseData = data(); + + List parameterSets = new ArrayList<>(); + for (Object[] base : baseData) { + for (Boolean l : booleans) { + for (Integer buf : BUFFERS) { + for (Boolean w : booleans) { + for (ResetType rt : ResetType.values()) { + for (Boolean f : booleans) { + parameterSets.add(new Object[] { + base[0], base[1], + l, buf, w, Integer.valueOf(1), rt, Integer.valueOf(512), f }); + } + } + } + } + } + } + return parameterSets; + } +} diff --git a/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1ValidWrite513.java b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1ValidWrite513.java new file mode 100644 index 000000000000..07761a7fc2ac --- /dev/null +++ b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite1ValidWrite513.java @@ -0,0 +1,55 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package jakarta.servlet.http; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +/* + * Split into multiple tests as a single test takes so long it impacts the time + * of an entire test run. + */ +@RunWith(Parameterized.class) +public class TestHttpServletDoHeadInvalidWrite1ValidWrite513 extends HttpServletDoHeadBaseTest { + + @Parameterized.Parameters(name = "{index}: {0} {1} {2} {3} {4} {5} {6} {7} {8}") + public static Collection parameters() { + Collection baseData = data(); + + List parameterSets = new ArrayList<>(); + for (Object[] base : baseData) { + for (Boolean l : booleans) { + for (Integer buf : BUFFERS) { + for (Boolean w : booleans) { + for (ResetType rt : ResetType.values()) { + for (Boolean f : booleans) { + parameterSets.add(new Object[] { + base[0], base[1], + l, buf, w, Integer.valueOf(1), rt, Integer.valueOf(513), f }); + } + } + } + } + } + } + return parameterSets; + } +} diff --git a/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite511ValidWrite0.java b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite511ValidWrite0.java new file mode 100644 index 000000000000..b99ef3c32539 --- /dev/null +++ b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite511ValidWrite0.java @@ -0,0 +1,55 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package jakarta.servlet.http; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +/* + * Split into multiple tests as a single test takes so long it impacts the time + * of an entire test run. + */ +@RunWith(Parameterized.class) +public class TestHttpServletDoHeadInvalidWrite511ValidWrite0 extends HttpServletDoHeadBaseTest { + + @Parameterized.Parameters(name = "{index}: {0} {1} {2} {3} {4} {5} {6} {7} {8}") + public static Collection parameters() { + Collection baseData = data(); + + List parameterSets = new ArrayList<>(); + for (Object[] base : baseData) { + for (Boolean l : booleans) { + for (Integer buf : BUFFERS) { + for (Boolean w : booleans) { + for (ResetType rt : ResetType.values()) { + for (Boolean f : booleans) { + parameterSets.add(new Object[] { + base[0], base[1], + l, buf, w, Integer.valueOf(511), rt, Integer.valueOf(0), f }); + } + } + } + } + } + } + return parameterSets; + } +} diff --git a/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite511ValidWrite1.java b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite511ValidWrite1.java new file mode 100644 index 000000000000..bb8c3cad3bb1 --- /dev/null +++ b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite511ValidWrite1.java @@ -0,0 +1,55 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package jakarta.servlet.http; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +/* + * Split into multiple tests as a single test takes so long it impacts the time + * of an entire test run. + */ +@RunWith(Parameterized.class) +public class TestHttpServletDoHeadInvalidWrite511ValidWrite1 extends HttpServletDoHeadBaseTest { + + @Parameterized.Parameters(name = "{index}: {0} {1} {2} {3} {4} {5} {6} {7} {8}") + public static Collection parameters() { + Collection baseData = data(); + + List parameterSets = new ArrayList<>(); + for (Object[] base : baseData) { + for (Boolean l : booleans) { + for (Integer buf : BUFFERS) { + for (Boolean w : booleans) { + for (ResetType rt : ResetType.values()) { + for (Boolean f : booleans) { + parameterSets.add(new Object[] { + base[0], base[1], + l, buf, w, Integer.valueOf(511), rt, Integer.valueOf(1), f }); + } + } + } + } + } + } + return parameterSets; + } +} diff --git a/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite511ValidWrite1023.java b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite511ValidWrite1023.java new file mode 100644 index 000000000000..bbcd2b18ebf3 --- /dev/null +++ b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite511ValidWrite1023.java @@ -0,0 +1,55 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package jakarta.servlet.http; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +/* + * Split into multiple tests as a single test takes so long it impacts the time + * of an entire test run. + */ +@RunWith(Parameterized.class) +public class TestHttpServletDoHeadInvalidWrite511ValidWrite1023 extends HttpServletDoHeadBaseTest { + + @Parameterized.Parameters(name = "{index}: {0} {1} {2} {3} {4} {5} {6} {7} {8}") + public static Collection parameters() { + Collection baseData = data(); + + List parameterSets = new ArrayList<>(); + for (Object[] base : baseData) { + for (Boolean l : booleans) { + for (Integer buf : BUFFERS) { + for (Boolean w : booleans) { + for (ResetType rt : ResetType.values()) { + for (Boolean f : booleans) { + parameterSets.add(new Object[] { + base[0], base[1], + l, buf, w, Integer.valueOf(511), rt, Integer.valueOf(1023), f }); + } + } + } + } + } + } + return parameterSets; + } +} diff --git a/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite511ValidWrite1024.java b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite511ValidWrite1024.java new file mode 100644 index 000000000000..a16f57a842e7 --- /dev/null +++ b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite511ValidWrite1024.java @@ -0,0 +1,55 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package jakarta.servlet.http; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +/* + * Split into multiple tests as a single test takes so long it impacts the time + * of an entire test run. + */ +@RunWith(Parameterized.class) +public class TestHttpServletDoHeadInvalidWrite511ValidWrite1024 extends HttpServletDoHeadBaseTest { + + @Parameterized.Parameters(name = "{index}: {0} {1} {2} {3} {4} {5} {6} {7} {8}") + public static Collection parameters() { + Collection baseData = data(); + + List parameterSets = new ArrayList<>(); + for (Object[] base : baseData) { + for (Boolean l : booleans) { + for (Integer buf : BUFFERS) { + for (Boolean w : booleans) { + for (ResetType rt : ResetType.values()) { + for (Boolean f : booleans) { + parameterSets.add(new Object[] { + base[0], base[1], + l, buf, w, Integer.valueOf(511), rt, Integer.valueOf(1024), f }); + } + } + } + } + } + } + return parameterSets; + } +} diff --git a/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite511ValidWrite1025.java b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite511ValidWrite1025.java new file mode 100644 index 000000000000..25cf96c97439 --- /dev/null +++ b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite511ValidWrite1025.java @@ -0,0 +1,55 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package jakarta.servlet.http; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +/* + * Split into multiple tests as a single test takes so long it impacts the time + * of an entire test run. + */ +@RunWith(Parameterized.class) +public class TestHttpServletDoHeadInvalidWrite511ValidWrite1025 extends HttpServletDoHeadBaseTest { + + @Parameterized.Parameters(name = "{index}: {0} {1} {2} {3} {4} {5} {6} {7} {8}") + public static Collection parameters() { + Collection baseData = data(); + + List parameterSets = new ArrayList<>(); + for (Object[] base : baseData) { + for (Boolean l : booleans) { + for (Integer buf : BUFFERS) { + for (Boolean w : booleans) { + for (ResetType rt : ResetType.values()) { + for (Boolean f : booleans) { + parameterSets.add(new Object[] { + base[0], base[1], + l, buf, w, Integer.valueOf(511), rt, Integer.valueOf(1025), f }); + } + } + } + } + } + } + return parameterSets; + } +} diff --git a/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite511ValidWrite511.java b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite511ValidWrite511.java new file mode 100644 index 000000000000..29f6895b48c2 --- /dev/null +++ b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite511ValidWrite511.java @@ -0,0 +1,55 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package jakarta.servlet.http; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +/* + * Split into multiple tests as a single test takes so long it impacts the time + * of an entire test run. + */ +@RunWith(Parameterized.class) +public class TestHttpServletDoHeadInvalidWrite511ValidWrite511 extends HttpServletDoHeadBaseTest { + + @Parameterized.Parameters(name = "{index}: {0} {1} {2} {3} {4} {5} {6} {7} {8}") + public static Collection parameters() { + Collection baseData = data(); + + List parameterSets = new ArrayList<>(); + for (Object[] base : baseData) { + for (Boolean l : booleans) { + for (Integer buf : BUFFERS) { + for (Boolean w : booleans) { + for (ResetType rt : ResetType.values()) { + for (Boolean f : booleans) { + parameterSets.add(new Object[] { + base[0], base[1], + l, buf, w, Integer.valueOf(511), rt, Integer.valueOf(511), f }); + } + } + } + } + } + } + return parameterSets; + } +} diff --git a/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite511ValidWrite512.java b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite511ValidWrite512.java new file mode 100644 index 000000000000..3aba507a2910 --- /dev/null +++ b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite511ValidWrite512.java @@ -0,0 +1,55 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package jakarta.servlet.http; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +/* + * Split into multiple tests as a single test takes so long it impacts the time + * of an entire test run. + */ +@RunWith(Parameterized.class) +public class TestHttpServletDoHeadInvalidWrite511ValidWrite512 extends HttpServletDoHeadBaseTest { + + @Parameterized.Parameters(name = "{index}: {0} {1} {2} {3} {4} {5} {6} {7} {8}") + public static Collection parameters() { + Collection baseData = data(); + + List parameterSets = new ArrayList<>(); + for (Object[] base : baseData) { + for (Boolean l : booleans) { + for (Integer buf : BUFFERS) { + for (Boolean w : booleans) { + for (ResetType rt : ResetType.values()) { + for (Boolean f : booleans) { + parameterSets.add(new Object[] { + base[0], base[1], + l, buf, w, Integer.valueOf(511), rt, Integer.valueOf(512), f }); + } + } + } + } + } + } + return parameterSets; + } +} diff --git a/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite511ValidWrite513.java b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite511ValidWrite513.java new file mode 100644 index 000000000000..0242718d022a --- /dev/null +++ b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite511ValidWrite513.java @@ -0,0 +1,55 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package jakarta.servlet.http; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +/* + * Split into multiple tests as a single test takes so long it impacts the time + * of an entire test run. + */ +@RunWith(Parameterized.class) +public class TestHttpServletDoHeadInvalidWrite511ValidWrite513 extends HttpServletDoHeadBaseTest { + + @Parameterized.Parameters(name = "{index}: {0} {1} {2} {3} {4} {5} {6} {7} {8}") + public static Collection parameters() { + Collection baseData = data(); + + List parameterSets = new ArrayList<>(); + for (Object[] base : baseData) { + for (Boolean l : booleans) { + for (Integer buf : BUFFERS) { + for (Boolean w : booleans) { + for (ResetType rt : ResetType.values()) { + for (Boolean f : booleans) { + parameterSets.add(new Object[] { + base[0], base[1], + l, buf, w, Integer.valueOf(511), rt, Integer.valueOf(513), f }); + } + } + } + } + } + } + return parameterSets; + } +} diff --git a/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite512ValidWrite0.java b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite512ValidWrite0.java new file mode 100644 index 000000000000..ad2cc7c54b50 --- /dev/null +++ b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite512ValidWrite0.java @@ -0,0 +1,55 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package jakarta.servlet.http; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +/* + * Split into multiple tests as a single test takes so long it impacts the time + * of an entire test run. + */ +@RunWith(Parameterized.class) +public class TestHttpServletDoHeadInvalidWrite512ValidWrite0 extends HttpServletDoHeadBaseTest { + + @Parameterized.Parameters(name = "{index}: {0} {1} {2} {3} {4} {5} {6} {7} {8}") + public static Collection parameters() { + Collection baseData = data(); + + List parameterSets = new ArrayList<>(); + for (Object[] base : baseData) { + for (Boolean l : booleans) { + for (Integer buf : BUFFERS) { + for (Boolean w : booleans) { + for (ResetType rt : ResetType.values()) { + for (Boolean f : booleans) { + parameterSets.add(new Object[] { + base[0], base[1], + l, buf, w, Integer.valueOf(512), rt, Integer.valueOf(0), f }); + } + } + } + } + } + } + return parameterSets; + } +} diff --git a/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite512ValidWrite1.java b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite512ValidWrite1.java new file mode 100644 index 000000000000..81a1d0137bbb --- /dev/null +++ b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite512ValidWrite1.java @@ -0,0 +1,55 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package jakarta.servlet.http; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +/* + * Split into multiple tests as a single test takes so long it impacts the time + * of an entire test run. + */ +@RunWith(Parameterized.class) +public class TestHttpServletDoHeadInvalidWrite512ValidWrite1 extends HttpServletDoHeadBaseTest { + + @Parameterized.Parameters(name = "{index}: {0} {1} {2} {3} {4} {5} {6} {7} {8}") + public static Collection parameters() { + Collection baseData = data(); + + List parameterSets = new ArrayList<>(); + for (Object[] base : baseData) { + for (Boolean l : booleans) { + for (Integer buf : BUFFERS) { + for (Boolean w : booleans) { + for (ResetType rt : ResetType.values()) { + for (Boolean f : booleans) { + parameterSets.add(new Object[] { + base[0], base[1], + l, buf, w, Integer.valueOf(512), rt, Integer.valueOf(1), f }); + } + } + } + } + } + } + return parameterSets; + } +} diff --git a/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite512ValidWrite1023.java b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite512ValidWrite1023.java new file mode 100644 index 000000000000..838915d6677e --- /dev/null +++ b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite512ValidWrite1023.java @@ -0,0 +1,55 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package jakarta.servlet.http; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +/* + * Split into multiple tests as a single test takes so long it impacts the time + * of an entire test run. + */ +@RunWith(Parameterized.class) +public class TestHttpServletDoHeadInvalidWrite512ValidWrite1023 extends HttpServletDoHeadBaseTest { + + @Parameterized.Parameters(name = "{index}: {0} {1} {2} {3} {4} {5} {6} {7} {8}") + public static Collection parameters() { + Collection baseData = data(); + + List parameterSets = new ArrayList<>(); + for (Object[] base : baseData) { + for (Boolean l : booleans) { + for (Integer buf : BUFFERS) { + for (Boolean w : booleans) { + for (ResetType rt : ResetType.values()) { + for (Boolean f : booleans) { + parameterSets.add(new Object[] { + base[0], base[1], + l, buf, w, Integer.valueOf(512), rt, Integer.valueOf(1023), f }); + } + } + } + } + } + } + return parameterSets; + } +} diff --git a/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite512ValidWrite1024.java b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite512ValidWrite1024.java new file mode 100644 index 000000000000..f1d0f0c6fa08 --- /dev/null +++ b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite512ValidWrite1024.java @@ -0,0 +1,55 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package jakarta.servlet.http; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +/* + * Split into multiple tests as a single test takes so long it impacts the time + * of an entire test run. + */ +@RunWith(Parameterized.class) +public class TestHttpServletDoHeadInvalidWrite512ValidWrite1024 extends HttpServletDoHeadBaseTest { + + @Parameterized.Parameters(name = "{index}: {0} {1} {2} {3} {4} {5} {6} {7} {8}") + public static Collection parameters() { + Collection baseData = data(); + + List parameterSets = new ArrayList<>(); + for (Object[] base : baseData) { + for (Boolean l : booleans) { + for (Integer buf : BUFFERS) { + for (Boolean w : booleans) { + for (ResetType rt : ResetType.values()) { + for (Boolean f : booleans) { + parameterSets.add(new Object[] { + base[0], base[1], + l, buf, w, Integer.valueOf(512), rt, Integer.valueOf(1024), f }); + } + } + } + } + } + } + return parameterSets; + } +} diff --git a/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite512ValidWrite1025.java b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite512ValidWrite1025.java new file mode 100644 index 000000000000..3bace1688d99 --- /dev/null +++ b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite512ValidWrite1025.java @@ -0,0 +1,55 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package jakarta.servlet.http; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +/* + * Split into multiple tests as a single test takes so long it impacts the time + * of an entire test run. + */ +@RunWith(Parameterized.class) +public class TestHttpServletDoHeadInvalidWrite512ValidWrite1025 extends HttpServletDoHeadBaseTest { + + @Parameterized.Parameters(name = "{index}: {0} {1} {2} {3} {4} {5} {6} {7} {8}") + public static Collection parameters() { + Collection baseData = data(); + + List parameterSets = new ArrayList<>(); + for (Object[] base : baseData) { + for (Boolean l : booleans) { + for (Integer buf : BUFFERS) { + for (Boolean w : booleans) { + for (ResetType rt : ResetType.values()) { + for (Boolean f : booleans) { + parameterSets.add(new Object[] { + base[0], base[1], + l, buf, w, Integer.valueOf(512), rt, Integer.valueOf(1025), f }); + } + } + } + } + } + } + return parameterSets; + } +} diff --git a/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite512ValidWrite511.java b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite512ValidWrite511.java new file mode 100644 index 000000000000..f2f9985e532d --- /dev/null +++ b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite512ValidWrite511.java @@ -0,0 +1,55 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package jakarta.servlet.http; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +/* + * Split into multiple tests as a single test takes so long it impacts the time + * of an entire test run. + */ +@RunWith(Parameterized.class) +public class TestHttpServletDoHeadInvalidWrite512ValidWrite511 extends HttpServletDoHeadBaseTest { + + @Parameterized.Parameters(name = "{index}: {0} {1} {2} {3} {4} {5} {6} {7} {8}") + public static Collection parameters() { + Collection baseData = data(); + + List parameterSets = new ArrayList<>(); + for (Object[] base : baseData) { + for (Boolean l : booleans) { + for (Integer buf : BUFFERS) { + for (Boolean w : booleans) { + for (ResetType rt : ResetType.values()) { + for (Boolean f : booleans) { + parameterSets.add(new Object[] { + base[0], base[1], + l, buf, w, Integer.valueOf(512), rt, Integer.valueOf(511), f }); + } + } + } + } + } + } + return parameterSets; + } +} diff --git a/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite512ValidWrite512.java b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite512ValidWrite512.java new file mode 100644 index 000000000000..3e7b63b86dd7 --- /dev/null +++ b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite512ValidWrite512.java @@ -0,0 +1,55 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package jakarta.servlet.http; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +/* + * Split into multiple tests as a single test takes so long it impacts the time + * of an entire test run. + */ +@RunWith(Parameterized.class) +public class TestHttpServletDoHeadInvalidWrite512ValidWrite512 extends HttpServletDoHeadBaseTest { + + @Parameterized.Parameters(name = "{index}: {0} {1} {2} {3} {4} {5} {6} {7} {8}") + public static Collection parameters() { + Collection baseData = data(); + + List parameterSets = new ArrayList<>(); + for (Object[] base : baseData) { + for (Boolean l : booleans) { + for (Integer buf : BUFFERS) { + for (Boolean w : booleans) { + for (ResetType rt : ResetType.values()) { + for (Boolean f : booleans) { + parameterSets.add(new Object[] { + base[0], base[1], + l, buf, w, Integer.valueOf(512), rt, Integer.valueOf(512), f }); + } + } + } + } + } + } + return parameterSets; + } +} diff --git a/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite512ValidWrite513.java b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite512ValidWrite513.java new file mode 100644 index 000000000000..ab9fc3df94af --- /dev/null +++ b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite512ValidWrite513.java @@ -0,0 +1,55 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package jakarta.servlet.http; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +/* + * Split into multiple tests as a single test takes so long it impacts the time + * of an entire test run. + */ +@RunWith(Parameterized.class) +public class TestHttpServletDoHeadInvalidWrite512ValidWrite513 extends HttpServletDoHeadBaseTest { + + @Parameterized.Parameters(name = "{index}: {0} {1} {2} {3} {4} {5} {6} {7} {8}") + public static Collection parameters() { + Collection baseData = data(); + + List parameterSets = new ArrayList<>(); + for (Object[] base : baseData) { + for (Boolean l : booleans) { + for (Integer buf : BUFFERS) { + for (Boolean w : booleans) { + for (ResetType rt : ResetType.values()) { + for (Boolean f : booleans) { + parameterSets.add(new Object[] { + base[0], base[1], + l, buf, w, Integer.valueOf(512), rt, Integer.valueOf(513), f }); + } + } + } + } + } + } + return parameterSets; + } +} diff --git a/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite513ValidWrite0.java b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite513ValidWrite0.java new file mode 100644 index 000000000000..5b50d1ee8a21 --- /dev/null +++ b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite513ValidWrite0.java @@ -0,0 +1,55 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package jakarta.servlet.http; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +/* + * Split into multiple tests as a single test takes so long it impacts the time + * of an entire test run. + */ +@RunWith(Parameterized.class) +public class TestHttpServletDoHeadInvalidWrite513ValidWrite0 extends HttpServletDoHeadBaseTest { + + @Parameterized.Parameters(name = "{index}: {0} {1} {2} {3} {4} {5} {6} {7} {8}") + public static Collection parameters() { + Collection baseData = data(); + + List parameterSets = new ArrayList<>(); + for (Object[] base : baseData) { + for (Boolean l : booleans) { + for (Integer buf : BUFFERS) { + for (Boolean w : booleans) { + for (ResetType rt : ResetType.values()) { + for (Boolean f : booleans) { + parameterSets.add(new Object[] { + base[0], base[1], + l, buf, w, Integer.valueOf(513), rt, Integer.valueOf(0), f }); + } + } + } + } + } + } + return parameterSets; + } +} diff --git a/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite513ValidWrite1.java b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite513ValidWrite1.java new file mode 100644 index 000000000000..cc80be1fb344 --- /dev/null +++ b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite513ValidWrite1.java @@ -0,0 +1,55 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package jakarta.servlet.http; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +/* + * Split into multiple tests as a single test takes so long it impacts the time + * of an entire test run. + */ +@RunWith(Parameterized.class) +public class TestHttpServletDoHeadInvalidWrite513ValidWrite1 extends HttpServletDoHeadBaseTest { + + @Parameterized.Parameters(name = "{index}: {0} {1} {2} {3} {4} {5} {6} {7} {8}") + public static Collection parameters() { + Collection baseData = data(); + + List parameterSets = new ArrayList<>(); + for (Object[] base : baseData) { + for (Boolean l : booleans) { + for (Integer buf : BUFFERS) { + for (Boolean w : booleans) { + for (ResetType rt : ResetType.values()) { + for (Boolean f : booleans) { + parameterSets.add(new Object[] { + base[0], base[1], + l, buf, w, Integer.valueOf(513), rt, Integer.valueOf(1), f }); + } + } + } + } + } + } + return parameterSets; + } +} diff --git a/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite513ValidWrite1023.java b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite513ValidWrite1023.java new file mode 100644 index 000000000000..58719116696b --- /dev/null +++ b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite513ValidWrite1023.java @@ -0,0 +1,55 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package jakarta.servlet.http; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +/* + * Split into multiple tests as a single test takes so long it impacts the time + * of an entire test run. + */ +@RunWith(Parameterized.class) +public class TestHttpServletDoHeadInvalidWrite513ValidWrite1023 extends HttpServletDoHeadBaseTest { + + @Parameterized.Parameters(name = "{index}: {0} {1} {2} {3} {4} {5} {6} {7} {8}") + public static Collection parameters() { + Collection baseData = data(); + + List parameterSets = new ArrayList<>(); + for (Object[] base : baseData) { + for (Boolean l : booleans) { + for (Integer buf : BUFFERS) { + for (Boolean w : booleans) { + for (ResetType rt : ResetType.values()) { + for (Boolean f : booleans) { + parameterSets.add(new Object[] { + base[0], base[1], + l, buf, w, Integer.valueOf(513), rt, Integer.valueOf(1023), f }); + } + } + } + } + } + } + return parameterSets; + } +} diff --git a/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite513ValidWrite1024.java b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite513ValidWrite1024.java new file mode 100644 index 000000000000..ac4f42a9b600 --- /dev/null +++ b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite513ValidWrite1024.java @@ -0,0 +1,55 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package jakarta.servlet.http; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +/* + * Split into multiple tests as a single test takes so long it impacts the time + * of an entire test run. + */ +@RunWith(Parameterized.class) +public class TestHttpServletDoHeadInvalidWrite513ValidWrite1024 extends HttpServletDoHeadBaseTest { + + @Parameterized.Parameters(name = "{index}: {0} {1} {2} {3} {4} {5} {6} {7} {8}") + public static Collection parameters() { + Collection baseData = data(); + + List parameterSets = new ArrayList<>(); + for (Object[] base : baseData) { + for (Boolean l : booleans) { + for (Integer buf : BUFFERS) { + for (Boolean w : booleans) { + for (ResetType rt : ResetType.values()) { + for (Boolean f : booleans) { + parameterSets.add(new Object[] { + base[0], base[1], + l, buf, w, Integer.valueOf(513), rt, Integer.valueOf(1024), f }); + } + } + } + } + } + } + return parameterSets; + } +} diff --git a/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite513ValidWrite1025.java b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite513ValidWrite1025.java new file mode 100644 index 000000000000..0e876c480efa --- /dev/null +++ b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite513ValidWrite1025.java @@ -0,0 +1,55 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package jakarta.servlet.http; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +/* + * Split into multiple tests as a single test takes so long it impacts the time + * of an entire test run. + */ +@RunWith(Parameterized.class) +public class TestHttpServletDoHeadInvalidWrite513ValidWrite1025 extends HttpServletDoHeadBaseTest { + + @Parameterized.Parameters(name = "{index}: {0} {1} {2} {3} {4} {5} {6} {7} {8}") + public static Collection parameters() { + Collection baseData = data(); + + List parameterSets = new ArrayList<>(); + for (Object[] base : baseData) { + for (Boolean l : booleans) { + for (Integer buf : BUFFERS) { + for (Boolean w : booleans) { + for (ResetType rt : ResetType.values()) { + for (Boolean f : booleans) { + parameterSets.add(new Object[] { + base[0], base[1], + l, buf, w, Integer.valueOf(513), rt, Integer.valueOf(1025), f }); + } + } + } + } + } + } + return parameterSets; + } +} diff --git a/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite513ValidWrite511.java b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite513ValidWrite511.java new file mode 100644 index 000000000000..ad5609a6db77 --- /dev/null +++ b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite513ValidWrite511.java @@ -0,0 +1,55 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package jakarta.servlet.http; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +/* + * Split into multiple tests as a single test takes so long it impacts the time + * of an entire test run. + */ +@RunWith(Parameterized.class) +public class TestHttpServletDoHeadInvalidWrite513ValidWrite511 extends HttpServletDoHeadBaseTest { + + @Parameterized.Parameters(name = "{index}: {0} {1} {2} {3} {4} {5} {6} {7} {8}") + public static Collection parameters() { + Collection baseData = data(); + + List parameterSets = new ArrayList<>(); + for (Object[] base : baseData) { + for (Boolean l : booleans) { + for (Integer buf : BUFFERS) { + for (Boolean w : booleans) { + for (ResetType rt : ResetType.values()) { + for (Boolean f : booleans) { + parameterSets.add(new Object[] { + base[0], base[1], + l, buf, w, Integer.valueOf(513), rt, Integer.valueOf(511), f }); + } + } + } + } + } + } + return parameterSets; + } +} diff --git a/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite513ValidWrite512.java b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite513ValidWrite512.java new file mode 100644 index 000000000000..4621616328bc --- /dev/null +++ b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite513ValidWrite512.java @@ -0,0 +1,55 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package jakarta.servlet.http; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +/* + * Split into multiple tests as a single test takes so long it impacts the time + * of an entire test run. + */ +@RunWith(Parameterized.class) +public class TestHttpServletDoHeadInvalidWrite513ValidWrite512 extends HttpServletDoHeadBaseTest { + + @Parameterized.Parameters(name = "{index}: {0} {1} {2} {3} {4} {5} {6} {7} {8}") + public static Collection parameters() { + Collection baseData = data(); + + List parameterSets = new ArrayList<>(); + for (Object[] base : baseData) { + for (Boolean l : booleans) { + for (Integer buf : BUFFERS) { + for (Boolean w : booleans) { + for (ResetType rt : ResetType.values()) { + for (Boolean f : booleans) { + parameterSets.add(new Object[] { + base[0], base[1], + l, buf, w, Integer.valueOf(513), rt, Integer.valueOf(512), f }); + } + } + } + } + } + } + return parameterSets; + } +} diff --git a/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite513ValidWrite513.java b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite513ValidWrite513.java new file mode 100644 index 000000000000..cbec1a10676a --- /dev/null +++ b/test/jakarta/servlet/http/TestHttpServletDoHeadInvalidWrite513ValidWrite513.java @@ -0,0 +1,55 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package jakarta.servlet.http; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +/* + * Split into multiple tests as a single test takes so long it impacts the time + * of an entire test run. + */ +@RunWith(Parameterized.class) +public class TestHttpServletDoHeadInvalidWrite513ValidWrite513 extends HttpServletDoHeadBaseTest { + + @Parameterized.Parameters(name = "{index}: {0} {1} {2} {3} {4} {5} {6} {7} {8}") + public static Collection parameters() { + Collection baseData = data(); + + List parameterSets = new ArrayList<>(); + for (Object[] base : baseData) { + for (Boolean l : booleans) { + for (Integer buf : BUFFERS) { + for (Boolean w : booleans) { + for (ResetType rt : ResetType.values()) { + for (Boolean f : booleans) { + parameterSets.add(new Object[] { + base[0], base[1], + l, buf, w, Integer.valueOf(513), rt, Integer.valueOf(513), f }); + } + } + } + } + } + } + return parameterSets; + } +} diff --git a/test/jakarta/servlet/http/TestHttpServletDoHeadValidWrite1023.java b/test/jakarta/servlet/http/TestHttpServletDoHeadValidWrite1023.java deleted file mode 100644 index 725a444497e7..000000000000 --- a/test/jakarta/servlet/http/TestHttpServletDoHeadValidWrite1023.java +++ /dev/null @@ -1,57 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package jakarta.servlet.http; - -import java.util.ArrayList; -import java.util.Collection; -import java.util.List; - -import org.junit.runner.RunWith; -import org.junit.runners.Parameterized; - -/* - * Split into multiple tests as a single test takes so long it impacts the time - * of an entire test run. - */ -@RunWith(Parameterized.class) -public class TestHttpServletDoHeadValidWrite1023 extends HttpServletDoHeadBaseTest { - - @Parameterized.Parameters(name = "{index}: {0} {1} {2} {3} {4} {5} {6} {7} {8}") - public static Collection parameters() { - Collection baseData = data(); - - List parameterSets = new ArrayList<>(); - for (Object[] base : baseData) { - for (Boolean l : booleans) { - for (Integer buf : BUFFERS) { - for (Boolean w : booleans) { - for (Integer c1 : COUNTS) { - for (ResetType rt : ResetType.values()) { - for (Boolean f : booleans) { - parameterSets.add(new Object[] { - base[0], base[1], - l, buf, w, c1, rt, Integer.valueOf(1023), f }); - } - } - } - } - } - } - } - return parameterSets; - } -} diff --git a/test/jakarta/servlet/http/TestHttpServletDoHeadValidWrite1024.java b/test/jakarta/servlet/http/TestHttpServletDoHeadValidWrite1024.java deleted file mode 100644 index 5900baaaf609..000000000000 --- a/test/jakarta/servlet/http/TestHttpServletDoHeadValidWrite1024.java +++ /dev/null @@ -1,57 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package jakarta.servlet.http; - -import java.util.ArrayList; -import java.util.Collection; -import java.util.List; - -import org.junit.runner.RunWith; -import org.junit.runners.Parameterized; - -/* - * Split into multiple tests as a single test takes so long it impacts the time - * of an entire test run. - */ -@RunWith(Parameterized.class) -public class TestHttpServletDoHeadValidWrite1024 extends HttpServletDoHeadBaseTest { - - @Parameterized.Parameters(name = "{index}: {0} {1} {2} {3} {4} {5} {6} {7} {8}") - public static Collection parameters() { - Collection baseData = data(); - - List parameterSets = new ArrayList<>(); - for (Object[] base : baseData) { - for (Boolean l : booleans) { - for (Integer buf : BUFFERS) { - for (Boolean w : booleans) { - for (Integer c1 : COUNTS) { - for (ResetType rt : ResetType.values()) { - for (Boolean f : booleans) { - parameterSets.add(new Object[] { - base[0], base[1], - l, buf, w, c1, rt, Integer.valueOf(1024), f }); - } - } - } - } - } - } - } - return parameterSets; - } -} diff --git a/test/jakarta/servlet/http/TestHttpServletDoHeadValidWrite1025.java b/test/jakarta/servlet/http/TestHttpServletDoHeadValidWrite1025.java deleted file mode 100644 index d72211a7b364..000000000000 --- a/test/jakarta/servlet/http/TestHttpServletDoHeadValidWrite1025.java +++ /dev/null @@ -1,57 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package jakarta.servlet.http; - -import java.util.ArrayList; -import java.util.Collection; -import java.util.List; - -import org.junit.runner.RunWith; -import org.junit.runners.Parameterized; - -/* - * Split into multiple tests as a single test takes so long it impacts the time - * of an entire test run. - */ -@RunWith(Parameterized.class) -public class TestHttpServletDoHeadValidWrite1025 extends HttpServletDoHeadBaseTest { - - @Parameterized.Parameters(name = "{index}: {0} {1} {2} {3} {4} {5} {6} {7} {8}") - public static Collection parameters() { - Collection baseData = data(); - - List parameterSets = new ArrayList<>(); - for (Object[] base : baseData) { - for (Boolean l : booleans) { - for (Integer buf : BUFFERS) { - for (Boolean w : booleans) { - for (Integer c1 : COUNTS) { - for (ResetType rt : ResetType.values()) { - for (Boolean f : booleans) { - parameterSets.add(new Object[] { - base[0], base[1], - l, buf, w, c1, rt, Integer.valueOf(1025), f }); - } - } - } - } - } - } - } - return parameterSets; - } -} diff --git a/test/jakarta/servlet/http/TestHttpServletDoHeadValidWrite513.java b/test/jakarta/servlet/http/TestHttpServletDoHeadValidWrite513.java deleted file mode 100644 index 0867fe784b5f..000000000000 --- a/test/jakarta/servlet/http/TestHttpServletDoHeadValidWrite513.java +++ /dev/null @@ -1,57 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package jakarta.servlet.http; - -import java.util.ArrayList; -import java.util.Collection; -import java.util.List; - -import org.junit.runner.RunWith; -import org.junit.runners.Parameterized; - -/* - * Split into multiple tests as a single test takes so long it impacts the time - * of an entire test run. - */ -@RunWith(Parameterized.class) -public class TestHttpServletDoHeadValidWrite513 extends HttpServletDoHeadBaseTest { - - @Parameterized.Parameters(name = "{index}: {0} {1} {2} {3} {4} {5} {6} {7} {8}") - public static Collection parameters() { - Collection baseData = data(); - - List parameterSets = new ArrayList<>(); - for (Object[] base : baseData) { - for (Boolean l : booleans) { - for (Integer buf : BUFFERS) { - for (Boolean w : booleans) { - for (Integer c1 : COUNTS) { - for (ResetType rt : ResetType.values()) { - for (Boolean f : booleans) { - parameterSets.add(new Object[] { - base[0], base[1], - l, buf, w, c1, rt, Integer.valueOf(513), f }); - } - } - } - } - } - } - } - return parameterSets; - } -}