Skip to content

Commit 82cdaf5

Browse files
dlunchdlunch
committed
Reorganize tests
1 parent 2c286dc commit 82cdaf5

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

79 files changed

+1727
-1876
lines changed

‎Cargo.lock‎

Lines changed: 13 additions & 2 deletions
Some generated files are not rendered by default. Learn more about customizing how changed files appear on GitHub.

‎Cargo.toml‎

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
11
[workspace]
2-
members = ["classfile", "java_runtime", "jvm", "jvm_rust"]
2+
members = ["classfile", "java_runtime", "jvm", "jvm_rust", "test_utils"]
33

44
[workspace.package]
55
version = "0.0.1"
@@ -26,6 +26,7 @@ java_constants = { path = "java_constants" }
2626
java_runtime = { path = "java_runtime" }
2727
jvm = { path = "jvm" }
2828
jvm_rust = { path = "jvm_rust" }
29+
test_utils = { path = "test_utils" }
2930

3031
[package]
3132
name = "rust_java"

‎java_runtime/Cargo.toml‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -24,4 +24,6 @@ jvm = { workspace = true }
2424

2525
[dev-dependencies]
2626
tokio = { workspace = true, features = ["rt-multi-thread", "time"] }
27+
2728
jvm_rust = { workspace = true }
29+
test_utils = { workspace = true }

‎java_runtime/src/classes/java/io/buffered_reader.rs‎

Lines changed: 0 additions & 32 deletions
Original file line numberDiff line numberDiff line change
@@ -100,35 +100,3 @@ impl BufferedReader {
100100
})
101101
}
102102
}
103-
104-
#[cfg(test)]
105-
mod test {
106-
use jvm::{runtime::JavaLangString, ClassInstanceRef, Result};
107-
108-
use crate::{classes::java::lang::String, test::test_jvm};
109-
110-
#[tokio::test]
111-
async fn test_buffered_reader() -> Result<()> {
112-
let jvm = test_jvm().await?;
113-
114-
let mut buffer = jvm.instantiate_array("B", 11).await?;
115-
jvm.array_raw_buffer_mut(&mut buffer).await?.write(0, b"Hello\nWorld")?;
116-
117-
let is = jvm.new_class("java/io/ByteArrayInputStream", "([B)V", (buffer,)).await?;
118-
let isr = jvm.new_class("java/io/InputStreamReader", "(Ljava/io/InputStream;)V", (is,)).await?;
119-
let reader = jvm.new_class("java/io/BufferedReader", "(Ljava/io/Reader;)V", (isr,)).await?;
120-
121-
let line = jvm.invoke_virtual(&reader, "readLine", "()Ljava/lang/String;", ()).await?;
122-
let line = JavaLangString::to_rust_string(&jvm, &line).await?;
123-
assert_eq!(line, "Hello");
124-
125-
let line = jvm.invoke_virtual(&reader, "readLine", "()Ljava/lang/String;", ()).await?;
126-
let line = JavaLangString::to_rust_string(&jvm, &line).await?;
127-
assert_eq!(line, "World");
128-
129-
let line: ClassInstanceRef<String> = jvm.invoke_virtual(&reader, "readLine", "()Ljava/lang/String;", ()).await?;
130-
assert!(line.is_null());
131-
132-
Ok(())
133-
}
134-
}

‎java_runtime/src/classes/java/io/byte_array_output_stream.rs‎

Lines changed: 0 additions & 32 deletions
Original file line numberDiff line numberDiff line change
@@ -107,35 +107,3 @@ impl ByteArrayOutputStream {
107107
Ok(())
108108
}
109109
}
110-
111-
#[cfg(test)]
112-
mod test {
113-
use alloc::vec;
114-
115-
use bytemuck::cast_vec;
116-
117-
use jvm::Result;
118-
119-
use crate::test::test_jvm;
120-
121-
#[tokio::test]
122-
async fn test_byte_array_output_stream() -> Result<()> {
123-
let jvm = test_jvm().await?;
124-
125-
let stream = jvm.new_class("java/io/ByteArrayOutputStream", "()V", ()).await?;
126-
let _: () = jvm.invoke_virtual(&stream, "write", "(I)V", (b'H' as i32,)).await?;
127-
let _: () = jvm.invoke_virtual(&stream, "write", "(I)V", (b'e' as i32,)).await?;
128-
let _: () = jvm.invoke_virtual(&stream, "write", "(I)V", (b'l' as i32,)).await?;
129-
let _: () = jvm.invoke_virtual(&stream, "write", "(I)V", (b'l' as i32,)).await?;
130-
let _: () = jvm.invoke_virtual(&stream, "write", "(I)V", (b'o' as i32,)).await?;
131-
132-
let buf = jvm.invoke_virtual(&stream, "toByteArray", "()[B", ()).await?;
133-
134-
let mut bytes = vec![0; 5];
135-
jvm.array_raw_buffer(&buf).await?.read(0, &mut bytes)?;
136-
137-
assert_eq!(bytes, cast_vec(b"Hello".to_vec()));
138-
139-
Ok(())
140-
}
141-
}

‎java_runtime/src/classes/java/io/data_input_stream.rs‎

Lines changed: 0 additions & 95 deletions
Original file line numberDiff line numberDiff line change
@@ -234,98 +234,3 @@ impl DataInputStream {
234234
Ok(())
235235
}
236236
}
237-
238-
#[cfg(test)]
239-
mod test {
240-
use alloc::vec;
241-
242-
use bytemuck::cast_vec;
243-
244-
use jvm::Result;
245-
246-
use crate::test::test_jvm;
247-
248-
#[tokio::test]
249-
async fn test_data_input_stream() -> Result<()> {
250-
let jvm = test_jvm().await?;
251-
252-
let data = vec![
253-
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
254-
0x18, 0x19, 0x1a, 0x1b,
255-
];
256-
let data_len = data.len();
257-
258-
let mut data_array = jvm.instantiate_array("B", data_len).await?;
259-
jvm.array_raw_buffer_mut(&mut data_array).await?.write(0, &data)?;
260-
261-
let input_stream = jvm.new_class("java/io/ByteArrayInputStream", "([B)V", (data_array,)).await?;
262-
let data_input_stream = jvm
263-
.new_class("java/io/DataInputStream", "(Ljava/io/InputStream;)V", (input_stream,))
264-
.await?;
265-
266-
let available: i32 = jvm.invoke_virtual(&data_input_stream, "available", "()I", ()).await?;
267-
assert_eq!(available, data_len as i32);
268-
269-
let byte: i8 = jvm.invoke_virtual(&data_input_stream, "readByte", "()B", ()).await?;
270-
assert_eq!(byte, 0x01);
271-
272-
let short: i16 = jvm.invoke_virtual(&data_input_stream, "readShort", "()S", ()).await?;
273-
assert_eq!(short, 0x0203);
274-
275-
let int: i32 = jvm.invoke_virtual(&data_input_stream, "readInt", "()I", ()).await?;
276-
assert_eq!(int, 0x04050607);
277-
278-
let long: i64 = jvm.invoke_virtual(&data_input_stream, "readLong", "()J", ()).await?;
279-
assert_eq!(long, 0x08090a0b0c0d0e0f);
280-
281-
let float: f32 = jvm.invoke_virtual(&data_input_stream, "readFloat", "()F", ()).await?;
282-
assert_eq!(float, f32::from_be_bytes([0x10, 0x11, 0x12, 0x13]));
283-
284-
let double: f64 = jvm.invoke_virtual(&data_input_stream, "readDouble", "()D", ()).await?;
285-
assert_eq!(double, f64::from_be_bytes([0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b]));
286-
287-
Ok(())
288-
}
289-
290-
#[tokio::test]
291-
async fn test_data_input_stream_high_bit() -> Result<()> {
292-
let jvm = test_jvm().await?;
293-
294-
let data = cast_vec(vec![
295-
0x81u8, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
296-
0x97, 0x98, 0x99, 0x9a, 0x9b,
297-
]);
298-
let data_len = data.len();
299-
300-
let mut data_array = jvm.instantiate_array("B", data_len).await?;
301-
jvm.array_raw_buffer_mut(&mut data_array).await?.write(0, &data)?;
302-
303-
let input_stream = jvm.new_class("java/io/ByteArrayInputStream", "([B)V", (data_array,)).await?;
304-
let data_input_stream = jvm
305-
.new_class("java/io/DataInputStream", "(Ljava/io/InputStream;)V", (input_stream,))
306-
.await?;
307-
308-
let available: i32 = jvm.invoke_virtual(&data_input_stream, "available", "()I", ()).await?;
309-
assert_eq!(available, data_len as i32);
310-
311-
let byte: i8 = jvm.invoke_virtual(&data_input_stream, "readByte", "()B", ()).await?;
312-
assert_eq!(byte, i8::from_be_bytes([0x81]));
313-
314-
let short: i16 = jvm.invoke_virtual(&data_input_stream, "readShort", "()S", ()).await?;
315-
assert_eq!(short, i16::from_be_bytes([0x82, 0x83]));
316-
317-
let int: i32 = jvm.invoke_virtual(&data_input_stream, "readInt", "()I", ()).await?;
318-
assert_eq!(int, i32::from_be_bytes([0x84, 0x85, 0x86, 0x87]));
319-
320-
let long: i64 = jvm.invoke_virtual(&data_input_stream, "readLong", "()J", ()).await?;
321-
assert_eq!(long, i64::from_be_bytes([0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f]));
322-
323-
let float: f32 = jvm.invoke_virtual(&data_input_stream, "readFloat", "()F", ()).await?;
324-
assert_eq!(float, f32::from_be_bytes([0x90, 0x91, 0x92, 0x93]));
325-
326-
let double: f64 = jvm.invoke_virtual(&data_input_stream, "readDouble", "()D", ()).await?;
327-
assert_eq!(double, f64::from_be_bytes([0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b]));
328-
329-
Ok(())
330-
}
331-
}

‎java_runtime/src/classes/java/io/data_output_stream.rs‎

Lines changed: 0 additions & 42 deletions
Original file line numberDiff line numberDiff line change
@@ -104,45 +104,3 @@ impl DataOutputStream {
104104
Ok(())
105105
}
106106
}
107-
108-
#[cfg(test)]
109-
mod test {
110-
use alloc::vec;
111-
112-
use jvm::{runtime::JavaLangString, Result};
113-
114-
use crate::test::test_jvm;
115-
116-
#[tokio::test]
117-
async fn test_data_output_stream() -> Result<()> {
118-
let jvm = test_jvm().await?;
119-
120-
let stream = jvm.new_class("java/io/ByteArrayOutputStream", "()V", ()).await?;
121-
let data_output_stream = jvm
122-
.new_class("java/io/DataOutputStream", "(Ljava/io/OutputStream;)V", (stream.clone(),))
123-
.await?;
124-
125-
let _: () = jvm.invoke_virtual(&data_output_stream, "write", "(I)V", (1,)).await?;
126-
let string = JavaLangString::from_rust_string(&jvm, "hello, world").await?;
127-
let _: () = jvm
128-
.invoke_virtual(&data_output_stream, "writeChars", "(Ljava/lang/String;)V", (string,))
129-
.await?;
130-
let _: () = jvm.invoke_virtual(&data_output_stream, "writeInt", "(I)V", (12341234,)).await?;
131-
let _: () = jvm.invoke_virtual(&data_output_stream, "writeLong", "(J)V", (123412341324i64,)).await?;
132-
133-
let bytes = jvm.invoke_virtual(&stream, "toByteArray", "()[B", ()).await?;
134-
135-
let length = jvm.array_length(&bytes).await?;
136-
let mut buf = vec![0; length];
137-
jvm.array_raw_buffer(&bytes).await?.read(0, &mut buf)?;
138-
139-
assert_eq!(
140-
buf,
141-
vec![
142-
1, b'h', b'e', b'l', b'l', b'o', b',', b' ', b'w', b'o', b'r', b'l', b'd', 0, 0xbc, 0x4f, 0xf2, 0, 0, 0, 0x1c, 0xbb, 0xf2, 0xe2, 0x4c
143-
]
144-
);
145-
146-
Ok(())
147-
}
148-
}

‎java_runtime/src/classes/java/io/input_stream_reader.rs‎

Lines changed: 0 additions & 35 deletions
Original file line numberDiff line numberDiff line change
@@ -178,38 +178,3 @@ impl InputStreamReader {
178178
Ok(())
179179
}
180180
}
181-
182-
#[cfg(test)]
183-
mod test {
184-
use alloc::{vec, vec::Vec};
185-
186-
use jvm::{JavaChar, Result};
187-
188-
use crate::test::test_jvm;
189-
190-
#[tokio::test]
191-
async fn test_isr() -> Result<()> {
192-
let jvm = test_jvm().await?;
193-
194-
let mut buffer = jvm.instantiate_array("B", 11).await?;
195-
jvm.array_raw_buffer_mut(&mut buffer).await?.write(0, b"Hello\nWorld")?;
196-
197-
let is = jvm.new_class("java/io/ByteArrayInputStream", "([B)V", (buffer,)).await?;
198-
let isr = jvm.new_class("java/io/InputStreamReader", "(Ljava/io/InputStream;)V", (is,)).await?;
199-
200-
let buf = jvm.instantiate_array("C", 10).await?;
201-
let read: i32 = jvm.invoke_virtual(&isr, "read", "([CII)I", (buf.clone(), 0, 5)).await?;
202-
203-
assert_eq!(read, 5);
204-
let buf_data: Vec<JavaChar> = jvm.load_array(&buf, 0, 5).await?;
205-
assert_eq!(buf_data, vec![72, 101, 108, 108, 111]);
206-
207-
let read: i32 = jvm.invoke_virtual(&isr, "read", "([CII)I", (buf.clone(), 0, 6)).await?;
208-
209-
assert_eq!(read, 6);
210-
let buf_data: Vec<JavaChar> = jvm.load_array(&buf, 0, 6).await?;
211-
assert_eq!(buf_data, vec![10, 87, 111, 114, 108, 100]);
212-
213-
Ok(())
214-
}
215-
}

‎java_runtime/src/classes/java/io/print_writer.rs‎

Lines changed: 0 additions & 28 deletions
Original file line numberDiff line numberDiff line change
@@ -64,31 +64,3 @@ impl PrintWriter {
6464
Ok(())
6565
}
6666
}
67-
68-
#[cfg(test)]
69-
mod tests {
70-
use jvm::{runtime::JavaLangString, ClassInstanceRef, Result};
71-
72-
use crate::{classes::java::lang::String, test::test_jvm};
73-
74-
#[tokio::test]
75-
async fn test_print_writer() -> Result<()> {
76-
let jvm = test_jvm().await?;
77-
78-
let sw = jvm.new_class("java/io/StringWriter", "()V", ()).await?;
79-
let pw = jvm.new_class("java/io/PrintWriter", "(Ljava/io/Writer;)V", (sw.clone(),)).await?;
80-
81-
let hello = JavaLangString::from_rust_string(&jvm, "hello").await?;
82-
let world = JavaLangString::from_rust_string(&jvm, "world").await?;
83-
84-
let _: () = jvm.invoke_virtual(&pw, "println", "(Ljava/lang/String;)V", (hello,)).await?;
85-
let _: () = jvm.invoke_virtual(&pw, "println", "(Ljava/lang/String;)V", (world,)).await?;
86-
87-
let result: ClassInstanceRef<String> = jvm.invoke_virtual(&sw, "toString", "()Ljava/lang/String;", ()).await?;
88-
let result = JavaLangString::to_rust_string(&jvm, &result).await?;
89-
90-
assert_eq!(result, "hello\nworld\n");
91-
92-
Ok(())
93-
}
94-
}

‎java_runtime/src/classes/java/io/random_access_file.rs‎

Lines changed: 0 additions & 32 deletions
Original file line numberDiff line numberDiff line change
@@ -211,35 +211,3 @@ impl RandomAccessFile {
211211
Ok(())
212212
}
213213
}
214-
215-
#[cfg(test)]
216-
mod test {
217-
use alloc::vec;
218-
219-
use jvm::{runtime::JavaLangString, Result};
220-
221-
use crate::test::test_jvm_filesystem;
222-
223-
#[tokio::test]
224-
async fn test_random_access_file() -> Result<()> {
225-
let filesystem = [("test.txt".into(), b"hello world".to_vec())];
226-
let jvm = test_jvm_filesystem(filesystem.into_iter().collect()).await?;
227-
228-
let file = JavaLangString::from_rust_string(&jvm, "test.txt").await?;
229-
let mode = JavaLangString::from_rust_string(&jvm, "r").await?;
230-
231-
let raf = jvm
232-
.new_class("java/io/RandomAccessFile", "(Ljava/lang/String;Ljava/lang/String;)V", (file, mode))
233-
.await?;
234-
235-
let buf = jvm.instantiate_array("B", 11).await?;
236-
let read: i32 = jvm.invoke_virtual(&raf, "read", "([B)I", (buf.clone(),)).await?;
237-
assert_eq!(read, 11);
238-
239-
let mut rust_buf = vec![0; 11];
240-
jvm.array_raw_buffer(&buf).await?.read(0, &mut rust_buf).unwrap();
241-
assert_eq!(rust_buf, vec![104, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100]);
242-
243-
Ok(())
244-
}
245-
}

0 commit comments

Comments
 (0)