tests.java.org.python.modules._io._ioTest Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of jython Show documentation
Show all versions of jython Show documentation
Jython is an implementation of the high-level, dynamic, object-oriented
language Python written in 100% Pure Java, and seamlessly integrated with
the Java platform. It thus allows you to run Python on any Java platform.
/* Copyright (c)2013 Jython Developers */
package org.python.modules._io;
import static org.junit.Assert.*;
import static org.junit.matchers.JUnitMatchers.*;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.util.Arrays;
import org.junit.Before;
import org.junit.Test;
import org.python.core.Py;
import org.python.core.PyException;
import org.python.core.PyFile;
import org.python.core.PyObject;
import org.python.core.PyStringMap;
import org.python.core.PySystemState;
import org.python.core.io.RawIOBase;
import org.python.util.PythonInterpreter;
/**
* Tests of specific methods in the Python _io module (org.python.modules._io._io). There is an
* extensive regression test in Lib/test/test_io.py, but that is quite complex. This test case
* exists to exercise selected functionality in isolation.
*/
public class _ioTest {
// Some file names to use
private final String FILE1 = "$test_1_tmp";
private final String FILE2 = "$test_2_tmp";
private final String FILE3 = "$test_3_tmp";
// We need the interpreter to be initialised for these tests.
PySystemState systemState;
PyStringMap dict;
PythonInterpreter interp;
/**
* Initialisation called before each test.
*
* @throws java.lang.Exception
*/
@Before
public void setUp() throws Exception {
// Initialise a Jython interpreter
systemState = Py.getSystemState();
dict = new PyStringMap();
interp = new PythonInterpreter(dict, systemState);
}
/**
* Test importing the _io module into the global namespace of {@link #interp}.
*/
@Test
public void moduleImport() {
interp.exec("import _io");
PyObject _io = interp.get("_io");
org.junit.Assert.assertNotNull(_io);
}
/**
* Test raising a Python _io.UnsupportedOperation from Java code directly.
*/
@Test
public void javaRaiseUnsupportedOperation() {
// Built-in modules seem not to initialise until we actually use an interpreter
interp.exec("import io");
// There should be a helper function
PyException pye = _jyio.UnsupportedOperation("Message from _ioTest");
PyObject type = pye.type;
String repr = type.toString();
assertEquals("Class name", "", repr);
// Raise from Java into Python and catch it in a variable: _IOBase.fileno() raises it
interp.exec("try :\n io.IOBase().fileno()\n" + "except Exception as e:\n pass");
PyObject e = interp.get("e");
String m = e.toString();
assertThat(m, both(containsString("UnsupportedOperation")).and(containsString("fileno")));
}
/**
* Test raising a Python _io.UnsupportedOperation from Python code into Java.
*/
@Test
public void pythonRaiseUnsupportedOperation() {
interp.exec("import _io");
try {
interp.exec("raise _io.UnsupportedOperation()");
fail("_io.UnsupportedOperation not raised when expected");
} catch (PyException e) {
assertEquals(_jyio.UnsupportedOperation, e.type);
}
}
/** Check PyFile().fileno() is acceptable to _io.open() */
@Test
public void openPyFileByFileno() throws IOException {
PySystemState sys = Py.getSystemState();
PyFile file = new PyFile(FILE1, "w", 1);
openByFilenoTest(file, "wb");
}
/** Check PyFile(OutputStream).fileno() is acceptable to _io.open() */
@Test
public void openPyFileOStreamByFileno() throws IOException {
PySystemState sys = Py.getSystemState();
OutputStream ostream = new FileOutputStream(FILE1);
PyFile file = new PyFile(ostream);
openByFilenoTest(file, "wb");
}
/** Check sys.stdin.fileno() is acceptable to _io.open() */
@Test
public void openStdinByFileno() throws IOException {
PySystemState sys = Py.getSystemState();
openByFilenoTest(sys.stdin, "rb");
}
/** Check sys.stdout.fileno() is acceptable to _io.open() */
@Test
public void openStdoutByFileno() throws IOException {
PySystemState sys = Py.getSystemState();
openByFilenoTest(sys.stdout, "wb");
}
/** Check sys.stderr.fileno() is acceptable to _io.open() */
@Test
public void openStderrByFileno() throws IOException {
PySystemState sys = Py.getSystemState();
openByFilenoTest(sys.stderr, "wb");
}
/**
* Test opening by a "file descriptor" obtained from another file or stream. The main purpose is
* to test that the return from fileno() is acceptable to _io.open().
*
* @param file anything with a "fileno" function
* @param mode mode string "rb" etc.
* @throws IOException
*/
public void openByFilenoTest(PyObject file, String mode) throws IOException {
PyObject pyfd = file.invoke("fileno");
RawIOBase fd = (RawIOBase)pyfd.__tojava__(RawIOBase.class);
PyObject[] args = new PyObject[] {pyfd, Py.newString(mode), Py.False};
String[] kwds = {"closefd"};
PyObject file2 = _jyio.open(args, kwds);
file2.invoke("close");
}
/**
* Test automatic closing of files when the interpreter finally exits. Done correctly, text
* written to any kind of file-like object should be flushed to disk and the file closed when
* the PySystemState is torn down, which happens during JVM exit. We don't here (can't?) test
* through JVM shutdown, but we test it using the same mechanism that a JVM shutdown invokes.
*
* @throws IOException
*/
@Test
public void closeNeglectedFiles() throws IOException {
// File names
final String F = FILE1; // Raw file
final String FB = FILE2; // Buffered file
final String FT = FILE3; // Test file
String expText = "Line 1\nLine 2\nLine 3."; // Note: all ascii, but with new lines
byte[] expBytes = expText.getBytes();
String escapedText = expText.replace("\n", "\\n");
// The approach is to open and write files in Python, then bin the interpreter
interp.exec("import io\n" + //
"u = u'" + escapedText + "'\n" + //
"b = b'" + escapedText + "'\n" //
);
// This should get us an io.FileIO (unbuffered binary file) called f
interp.exec("f = io.open('" + F + "', 'wb', 0)");
PyIOBase pyf = (PyIOBase)interp.get("f");
assertNotNull(pyf);
// This should get us an io.BufferedWriter (buffered binary file) called fb
interp.exec("fb = io.open('" + FB + "', 'wb')");
PyIOBase pyfb = (PyIOBase)interp.get("fb");
assertNotNull(pyfb);
// This should get us an io.TextIOWrapper (buffered text file) called ft
interp.exec("ft = io.open('" + FT + "', 'w', encoding='ascii')");
PyIOBase pyft = (PyIOBase)interp.get("ft");
assertNotNull(pyft);
// Write the bytes test material to each file but don't close it
interp.exec("f.write(b)");
interp.exec("fb.write(b)");
interp.exec("ft.write(u)");
// Now bin the interpreter. (Is there a more realistic way?)
interp.cleanup();
// Check file itself for closure using package-visible attribute
assertTrue(pyf.__closed);
assertTrue(pyfb.__closed);
assertTrue(pyft.__closed);
// If they were not closed properly not all bytes will reach the files.
checkFileContent(F, expBytes, true);
checkFileContent(FB, expBytes, true);
// Expect that TextIOWrapper should have adjusted the line separator
checkFileContent(FT, newlineFix(expText), true);
}
/**
* Test automatic closing of PyFiles when the interpreter finally exits. This repeats
* {@link #closeNeglectedFiles()} but for the py2k flavour of file.
*
* @throws IOException
*/
@Test
public void closeNeglectedPyFiles() throws IOException {
// File names
final String F = FILE1; // Raw file
final String FB = FILE2; // Buffered file
final String FT = FILE3; // Test file
String expText = "Line 1\nLine 2\nLine 3.";
byte[] expBytes = expText.getBytes();
String escapedText = expText.replace("\n", "\\n");
// The approach is to open and write files in Python, then bin the interpreter
interp.exec("import io\n" + //
"u = u'" + escapedText + "'\n" + //
"b = b'" + escapedText + "'\n" //
);
// This should get us an unbuffered binary PyFile called f
interp.exec("f = open('" + F + "', 'wb', 0)");
PyFile pyf = (PyFile)interp.get("f");
assertNotNull(pyf);
RawIOBase r = (RawIOBase)pyf.fileno().__tojava__(RawIOBase.class);
// This should get us a buffered binary PyFile called fb
interp.exec("fb = open('" + FB + "', 'wb')");
PyFile pyfb = (PyFile)interp.get("fb");
assertNotNull(pyfb);
RawIOBase rb = (RawIOBase)pyfb.fileno().__tojava__(RawIOBase.class);
// This should get us an buffered text PyFile called ft
interp.exec("ft = open('" + FT + "', 'w')");
PyFile pyft = (PyFile)interp.get("ft");
assertNotNull(pyft);
RawIOBase rt = (RawIOBase)pyft.fileno().__tojava__(RawIOBase.class);
// Write the bytes test material to each file but don't close it
interp.exec("f.write(b)");
interp.exec("fb.write(b)");
interp.exec("ft.write(u)");
// Now bin the interpreter. (Is there a more realistic way?)
interp.cleanup();
// The PyFile itself is not closed but the underlying stream should be
assertTrue(r.closed());
assertTrue(rb.closed());
assertTrue(rt.closed());
// If they were not closed properly not all bytes will reach the files.
checkFileContent(F, expBytes, true);
checkFileContent(FB, expBytes, true);
// Expect that TextIOWrapper should have adjusted the line separator
checkFileContent(FT, newlineFix(expText), true);
}
/**
* Check the file contains the bytes we expect and optionally delete the file. If it was
* not closed properly (layers in the right order and a flush) not all bytes will have reached
* the files.
*
* @param name of file
* @param expBytes expected
* @param delete the file if true
* @throws IOException if cannot open/read
*/
private static void checkFileContent(String name, byte[] expBytes, boolean delete)
throws IOException {
// Open and read
byte[] r = new byte[2 * expBytes.length];
File f = new File(name);
FileInputStream in = new FileInputStream(f);
int n = in.read(r);
in.close();
// Check as expected
String msg = "Bytes read from " + name;
assertEquals(msg, expBytes.length, n);
byte[] resBytes = Arrays.copyOf(r, n);
assertArrayEquals(msg, expBytes, resBytes);
// Delete the file
if (delete) {
f.delete();
}
}
/**
* Replace "\n" characters by the system-defined newline sequence and return as bytes.
*
* @param expText to translate
* @return result as bytes
*/
private static byte[] newlineFix(String expText) {
String newline = System.getProperty("line.separator");
return expText.replace("\n", newline).getBytes();
}
}