/*
* 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 org.apache.tomcat.util.buf;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.function.Consumer;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameter;
import org.junit.runners.Parameterized.Parameters;
/**
* Checks that all MessageBytes getters are consistent with most recently used
* setter.
*/
@RunWith(Parameterized.class)
public class TestMessageBytesConversion {
private static final String PREVIOUS_STRING = "previous-string";
private static final byte[] PREVIOUS_BYTES = "previous-bytes".getBytes(StandardCharsets.ISO_8859_1);
private static final char[] PREVIOUS_CHARS = "previous-chars".toCharArray();
private static final String EXPECTED_STRING = "expected";
private static final byte[] EXPECTED_BYTES = "expected".getBytes(StandardCharsets.ISO_8859_1);
private static final char[] EXPECTED_CHARS = "expected".toCharArray();
@Parameters(name = "{index}: previous({0}, {1}, {2}, {3}), set {4}, check({5}, {6}, {7}")
public static Collection<Object[]> parameters() {
List<MessageBytesType> previousTypes = new ArrayList<>();
previousTypes.add(MessageBytesType.BYTE);
previousTypes.add(MessageBytesType.CHAR);
previousTypes.add(MessageBytesType.STRING);
previousTypes.add(MessageBytesType.NULL);
List<MessageBytesType> setTypes = new ArrayList<>();
setTypes.add(MessageBytesType.BYTE);
setTypes.add(MessageBytesType.CHAR);
setTypes.add(MessageBytesType.STRING);
List<Object[]> parameterSets = new ArrayList<>();
List<List<MessageBytesType>> previousPermutations = permutations(previousTypes);
List<List<MessageBytesType>> checkPermutations = permutations(setTypes);
for (List<MessageBytesType> setPermutation : previousPermutations) {
for (MessageBytesType setType : setTypes) {
for (List<MessageBytesType> checkPermutation : checkPermutations) {
parameterSets.add(new Object[] {
setPermutation.get(0), setPermutation.get(1), setPermutation.get(2), setPermutation.get(3),
setType,
checkPermutation.get(0), checkPermutation.get(1), checkPermutation.get(2)});
}
}
}
return parameterSets;
}
@Parameter(0)
public MessageBytesType setFirst;
@Parameter(1)
public MessageBytesType setSecond;
@Parameter(2)
public MessageBytesType setThird;
@Parameter(3)
public MessageBytesType setFourth;
@Parameter(4)
public MessageBytesType expected;
@Parameter(5)
public MessageBytesType checkFirst;
@Parameter(6)
public MessageBytesType checkSecond;
@Parameter(7)
public MessageBytesType checkThird;
@Test
public void testConversion() {
MessageBytes mb = MessageBytes.newInstance();
setFirst.setPrevious(mb);
setSecond.setPrevious(mb);
setThird.setPrevious(mb);
setFourth.setPrevious(mb);
expected.setExpected(mb);
checkFirst.checkExpected(mb);
checkSecond.checkExpected(mb);
checkThird.checkExpected(mb);
}
@Test
public void testConversionNull() {
MessageBytes mb = MessageBytes.newInstance();
setFirst.setPrevious(mb);
setSecond.setPrevious(mb);
setThird.setPrevious(mb);
setFourth.setPrevious(mb);
mb.setString(null);
checkFirst.checkNull(mb);
checkSecond.checkNull(mb);
checkThird.checkNull(mb);
}
public enum MessageBytesType {
BYTE((x) -> x.setBytes(PREVIOUS_BYTES, 0, PREVIOUS_BYTES.length),
(x) -> x.setBytes(EXPECTED_BYTES, 0, EXPECTED_BYTES.length),
(x) -> {x.toBytes(); Assert.assertTrue(x.getByteChunk().equals(EXPECTED_BYTES, 0, EXPECTED_BYTES.length) );},
(x) -> {x.toBytes(); Assert.assertTrue(x.getByteChunk().isNull());}),
CHAR((x) -> x.setChars(PREVIOUS_CHARS, 0, PREVIOUS_CHARS.length),
(x) -> x.setChars(EXPECTED_CHARS, 0, EXPECTED_CHARS.length),
(x) -> {x.toChars(); Assert.assertArrayEquals(EXPECTED_CHARS, x.getCharChunk().getChars());},
(x) -> {x.toChars(); Assert.assertTrue(x.getCharChunk().isNull());}),
STRING((x) -> x.setString(PREVIOUS_STRING),
(x) -> x.setString(EXPECTED_STRING),
(x) -> Assert.assertEquals(EXPECTED_STRING, x.toString()),
(x) -> Assert.assertNull(x.toString())),
NULL((x) -> x.setString(null),
(x) -> x.setString(null),
(x) -> Assert.assertTrue(x.isNull()),
(x) -> Assert.assertTrue(x.isNull()));
private final Consumer<MessageBytes> setPrevious;
private final Consumer<MessageBytes> setExpected;
private final Consumer<MessageBytes> checkExpected;
private final Consumer<MessageBytes> checkNull;
MessageBytesType(Consumer<MessageBytes> setPrevious, Consumer<MessageBytes> setExpected,
Consumer<MessageBytes> checkExpected, Consumer<MessageBytes> checkNull) {
this.setPrevious = setPrevious;
this.setExpected = setExpected;
this.checkExpected = checkExpected;
this.checkNull = checkNull;
}
public void setPrevious(MessageBytes mb) {
setPrevious.accept(mb);
}
public void setExpected(MessageBytes mb) {
setExpected.accept(mb);
}
public void checkExpected(MessageBytes mb) {
checkExpected.accept(mb);
}
public void checkNull(MessageBytes mb) {
checkNull.accept(mb);
}
}
private static <T> List<List<T>> permutations(List<T> items) {
List<List<T>> results = new ArrayList<>();
if (items.size() == 1) {
results.add(items);
} else {
List<T> others = new ArrayList<>(items);
T first = others.remove(0);
List<List<T>> subPermutations = permutations(others);
for (List<T> subPermutation : subPermutations) {
for (int i = 0; i <= subPermutation.size(); i++) {
List<T> result = new ArrayList<>(subPermutation);
result.add(i, first);
results.add(result);
}
}
}
return results;
}
}