Fatal编程技术网
  • java/
  • Java 字符串序列化单元测试失败

Java 字符串序列化单元测试失败

java string serialization junit

Java 字符串序列化单元测试失败,java,string,serialization,junit,Java,String,Serialization,Junit,对String序列化运行Junit测试后，该测试失败，并给出以下结果： 应为：“网络模型” 实际值：“l” 序列化方法如下所示 public static void serializeString(String objectToSerialize, OutputStream outputStream) { byte[] bytesArr = objectToSerialize.getBytes(); serializeInt(bytesArr.length, outputStre

对
String
序列化运行Junit测试后，该测试失败，并给出以下结果：

应为：
“网络模型”

实际值：
“l”

序列化方法如下所示

public static void serializeString(String objectToSerialize, OutputStream outputStream) {
    byte[] bytesArr = objectToSerialize.getBytes();
    serializeInt(bytesArr.length, outputStream);
    try {

        outputStream.write(bytesArr);
    } catch (IOException e) {
        e.printStackTrace();
    }
}

public static String deserializeString(InputStream inputStream) {
String deserializeObject = "";
char asciiToChar;
int stringByteArrayLength = deserializeInt(inputStream);
byte[] databytesArr = new byte[stringByteArrayLength];

try {
  inputStream.read(databytesArr, 0, stringByteArrayLength);
}
catch (IOException e) {
  e.printStackTrace();
}

for (int i = 0; i < databytesArr.length; i++) {
  asciiToChar = (char) databytesArr[i];
  deserializeObject = "" + Character.toString(asciiToChar);
}
return deserializeObject;
} 

public class StringSerializerTest {

  private InputStream iStream;
  private ByteArrayOutputStream oStream;

  @Before
  public void init() {
    oStream = new ByteArrayOutputStream();
  }

  String serialzeAndDeserializeObject(String stringValue) {
    OutputStreamUtil.serializeString(stringValue, oStream);
    iStream = new ByteArrayInputStream(oStream.toByteArray());
    return InputStreamUtil.deserializeString(iStream);
  }

  @Test
  public void equals_equal() {
    String stringValue = "netmodel";
    String deserializedStringValue = serialzeAndDeserializeObject(stringValue);
    assertThat(deserializedStringValue).isEqualTo(stringValue);
  }
}
我的反序列化方法如下

public static void serializeString(String objectToSerialize, OutputStream outputStream) {
    byte[] bytesArr = objectToSerialize.getBytes();
    serializeInt(bytesArr.length, outputStream);
    try {

        outputStream.write(bytesArr);
    } catch (IOException e) {
        e.printStackTrace();
    }
}

public static String deserializeString(InputStream inputStream) {
String deserializeObject = "";
char asciiToChar;
int stringByteArrayLength = deserializeInt(inputStream);
byte[] databytesArr = new byte[stringByteArrayLength];

try {
  inputStream.read(databytesArr, 0, stringByteArrayLength);
}
catch (IOException e) {
  e.printStackTrace();
}

for (int i = 0; i < databytesArr.length; i++) {
  asciiToChar = (char) databytesArr[i];
  deserializeObject = "" + Character.toString(asciiToChar);
}
return deserializeObject;
} 

public class StringSerializerTest {

  private InputStream iStream;
  private ByteArrayOutputStream oStream;

  @Before
  public void init() {
    oStream = new ByteArrayOutputStream();
  }

  String serialzeAndDeserializeObject(String stringValue) {
    OutputStreamUtil.serializeString(stringValue, oStream);
    iStream = new ByteArrayInputStream(oStream.toByteArray());
    return InputStreamUtil.deserializeString(iStream);
  }

  @Test
  public void equals_equal() {
    String stringValue = "netmodel";
    String deserializedStringValue = serialzeAndDeserializeObject(stringValue);
    assertThat(deserializedStringValue).isEqualTo(stringValue);
  }
}
怎么了？以及如何修复它？

在每个迭代过程中，您将重新分配
反序列化对象的整个值


for (int i = 0; i < databytesArr.length; i++) {
    asciiToChar = (char) databytesArr[i];
    deserializeObject = "" + Character.toString(asciiToChar);
}


更正的反序列化逻辑为：


public static String deserializeString(InputStream inputStream) {
    String deserializeObject = "";
    char asciiToChar;
    int stringByteArrayLength = deserializeInt(inputStream);
    byte[] databytesArr = new byte[stringByteArrayLength];

    try {
        inputStream.read(databytesArr, 0, stringByteArrayLength);
    }
    catch (IOException e) {
        e.printStackTrace();
    }

    for (int i = 0; i < databytesArr.length; i++) {
        asciiToChar = (char) databytesArr[i];
        deserializeObject += Character.toString(asciiToChar);
    }
    return deserializeObject;
} 



公共静态字符串反序列化字符串（InputStream InputStream）{
字符串反序列化对象=”；
半焦；
int StringByteArrayleLength=反序列化int（inputStream）；
字节[]数据字节R=新字节[StringByteArrayleLength]；
试一试{
读取（数据字节，0，StringByteArrayleLength）；
}
捕获（IOE异常）{
e、 printStackTrace（）；
}
对于（int i=0；i
在每次迭代过程中，您将重新分配
反序列化对象的整个值


for (int i = 0; i < databytesArr.length; i++) {
    asciiToChar = (char) databytesArr[i];
    deserializeObject = "" + Character.toString(asciiToChar);
}


更正的反序列化逻辑为：


public static String deserializeString(InputStream inputStream) {
    String deserializeObject = "";
    char asciiToChar;
    int stringByteArrayLength = deserializeInt(inputStream);
    byte[] databytesArr = new byte[stringByteArrayLength];

    try {
        inputStream.read(databytesArr, 0, stringByteArrayLength);
    }
    catch (IOException e) {
        e.printStackTrace();
    }

    for (int i = 0; i < databytesArr.length; i++) {
        asciiToChar = (char) databytesArr[i];
        deserializeObject += Character.toString(asciiToChar);
    }
    return deserializeObject;
} 



公共静态字符串反序列化字符串（InputStream InputStream）{
字符串反序列化对象=”；
半焦；
int StringByteArrayleLength=反序列化int（inputStream）；
字节[]数据字节R=新字节[StringByteArrayleLength]；
试一试{
读取（数据字节，0，StringByteArrayleLength）；
}
捕获（IOE异常）{
e、 printStackTrace（）；
}
对于（int i=0；i
贾斯汀·阿尔巴诺已经报告了错误。
但是，也要注意带有非ASCII:类特殊字符的字符串

类似下面的内容。还应在末端关闭，以确保在缓冲流的情况下进行冲洗。理论上，读取只能产生阵列的非阻塞部分
DataOutputStream
有很好的方法，尽管您似乎可以进行自己的序列化


public static void serializeString(String objectToSerialize, OutputStream outputStream)
        throws IOException {
    byte[] bytesArr = objectToSerialize.getBytes(StandardCharsets.UTF_8);
    serializeInt(bytesArr.length, outputStream);
    outputStream.write(bytesArr);
}

public static String deserializeString(InputStream inputStream)
        throws IOException {
    int stringByteArrayLength = deserializeInt(inputStream);
    byte[] databytesArr = new byte[stringByteArrayLength];
    readFully(inputStream, databytesArr);
    return new String(databytesArr, StandardCharsets.UTF_8);
}

private static void readFully(InputStream inputStream, byte[] bytes) throws IOException {
    int i = 0;
    while (i < bytes.length) {
        int nread = inputStream.read(bytes, i, bytes.length - i);
        if (nread <= 0) {
            throw new IOException("Premature EOF");
        }
        i += nread;
    }
}



public static void serializeString（String objectToSerialize，OutputStream OutputStream）
抛出IOException{
byte[]bytesArr=objectToSerialize.getBytes（StandardCharsets.UTF_8）；
serializeInt（bytesArr.length，outputStream）；
outputStream.write（字节数）；
}
公共静态字符串反序列化字符串（InputStream InputStream）
抛出IOException{
int StringByteArrayleLength=反序列化int（inputStream）；
字节[]数据字节R=新字节[StringByteArrayleLength]；
准备就绪（输入流、数据字节）；
返回新字符串（databytesArr、StandardCharsets.UTF_8）；
}
私有静态void readFully（InputStream InputStream，字节[]字节）引发IOException{
int i=0；
while（i如果（nread该错误已由Justin Albano报告。
但是，也要注意带有非ASCII:类特殊字符的字符串

类似于下面的内容。另外，应该在最后关闭，以确保在缓冲流的情况下进行刷新。理论上，读取只能产生阵列的非阻塞部分。
DataOutputStream
有很好的方法，尽管您似乎可以自己进行序列化


public static void serializeString(String objectToSerialize, OutputStream outputStream)
        throws IOException {
    byte[] bytesArr = objectToSerialize.getBytes(StandardCharsets.UTF_8);
    serializeInt(bytesArr.length, outputStream);
    outputStream.write(bytesArr);
}

public static String deserializeString(InputStream inputStream)
        throws IOException {
    int stringByteArrayLength = deserializeInt(inputStream);
    byte[] databytesArr = new byte[stringByteArrayLength];
    readFully(inputStream, databytesArr);
    return new String(databytesArr, StandardCharsets.UTF_8);
}

private static void readFully(InputStream inputStream, byte[] bytes) throws IOException {
    int i = 0;
    while (i < bytes.length) {
        int nread = inputStream.read(bytes, i, bytes.length - i);
        if (nread <= 0) {
            throw new IOException("Premature EOF");
        }
        i += nread;
    }
}



public static void serializeString（String objectToSerialize，OutputStream OutputStream）
抛出IOException{
byte[]bytesArr=objectToSerialize.getBytes（StandardCharsets.UTF_8）；
serializeInt（bytesArr.length，outputStream）；
outputStream.write（字节数）；
}
公共静态字符串反序列化字符串（InputStream InputStream）
抛出IOException{
int StringByteArrayleLength=反序列化int（inputStream）；
字节[]数据字节R=新字节[StringByteArrayleLength]；
准备就绪（输入流、数据字节）；
返回新字符串（databytesArr、StandardCharsets.UTF_8）；
}
私有静态void readFully（InputStream InputStream，字节[]字节）引发IOException{
int i=0；
while（i如果（nread）您正在调用
serializeInt（）
——这是复制粘贴错误还是您的实际问题？您正在调用
serializeInt（）
——这是复制粘贴错误还是您的实际问题？