fd = open ("fdopen.tst", O_RDONLY | O_BINARY);
file = fdopen (fd, "rb");
setvbuf(file,NULL,bufmodes[bufmode],2048);
+ if(bufmodes[bufmode] == _IOFBF)
+ ok(file->_bufsiz == 2048, "file->_bufsiz = %d\n", file->_bufsiz);
+ ok(file->_base != NULL, "file->_base = NULL\n");
ok(strlen(outbuffer) == (sizeof(outbuffer)-1),"strlen/sizeof error for bufmode=%x\n", bufmodes[bufmode]);
ok(fgets(buffer,sizeof(buffer),file) !=0,"fgets failed unexpected for bufmode=%x\n", bufmodes[bufmode]);
ok(fgets(buffer,sizeof(buffer),file) ==0,"fgets didn't signal EOF for bufmode=%x\n", bufmodes[bufmode]);
ok(tempfh->_cnt == 0, "_cnt on freshly opened file was %d\n", tempfh->_cnt);
setbuf(tempfh, NULL);
ok(tempfh->_cnt == 0, "_cnt on unbuffered file was %d\n", tempfh->_cnt);
+ ok(tempfh->_bufsiz == 2, "_bufsiz = %d\n", tempfh->_bufsiz);
/* Inlined putchar sets _cnt to -1. Native seems to ignore the value... */
tempfh->_cnt = 1234;
ret = _flsbuf('Q',tempfh);
"Wrong write result in child process on %d (%s)\n", fd, strerror(errno));
}
+static void test_file_refcount_child(void)
+{
+ static const char buffer1[] = "test1";
+ static const char buffer2[] = "test2";
+ static const char buffer3[] = "test3";
+ static const char buffer4[] = "test4";
+ HANDLE f0, f1, f2, h0, h1, h2;
+ DWORD written, flags, ret;
+
+ f0 = (HANDLE)_get_osfhandle(STDIN_FILENO);
+ f1 = (HANDLE)_get_osfhandle(STDOUT_FILENO);
+ f2 = (HANDLE)_get_osfhandle(STDERR_FILENO);
+ ok(f0 == f1, "expected same handles, got %p, %p\n", f0, f1);
+ ok(f1 == f2, "expected same handles, got %p, %p\n", f1, f2);
+
+ h0 = GetStdHandle(STD_INPUT_HANDLE);
+ h1 = GetStdHandle(STD_OUTPUT_HANDLE);
+ h2 = GetStdHandle(STD_ERROR_HANDLE);
+ ok(h0 == h1, "expected same handles, got %p, %p\n", h0, h1);
+ ok(h1 == h2, "expected same handles, got %p, %p\n", h1, h2);
+ ok(f0 == h0, "expected same handles, got %p, %p\n", f0, h0);
+
+ ret = GetHandleInformation(h1, &flags);
+ ok(ret, "GetHandleInformation failed\n");
+ ret = WriteFile(h1, buffer1, strlen(buffer1), &written, 0);
+ ok(ret, "WriteFile failed\n");
+
+ ret = fclose(stdout);
+ ok(ret == 0, "fclose failed\n");
+ ret = GetHandleInformation(h1, &flags);
+ ok(ret, "GetHandleInformation failed\n");
+ ret = WriteFile(h1, buffer2, strlen(buffer2), &written, 0);
+ ok(ret, "WriteFile failed\n");
+
+ ret = fclose(stdout);
+ ok(ret != 0, "fclose should fail\n");
+ ret = GetHandleInformation(h1, &flags);
+ ok(ret, "GetHandleInformation failed\n");
+ ret = WriteFile(h1, buffer3, strlen(buffer3), &written, 0);
+ ok(ret, "WriteFile failed\n");
+
+ ret = fclose(stderr);
+ ok(ret == 0, "fclose failed\n");
+ ret = GetHandleInformation(h1, &flags);
+ ok(!ret, "GetHandleInformation should fail\n");
+ ret = WriteFile(h1, buffer4, strlen(buffer4), &written, 0);
+ ok(!ret, "WriteFile should fail\n");
+}
+
static void create_io_inherit_block( STARTUPINFOA *startup, unsigned int count, const HANDLE *handles )
{
static BYTE block[1024];
DeleteFileA( "fdopen.err" );
}
+static void test_file_refcount( STARTUPINFOA *startup, char *cmdline, const char *descr )
+{
+ const char *data;
+ HANDLE hMixFile;
+ SECURITY_ATTRIBUTES sa;
+ PROCESS_INFORMATION proc;
+
+ /* make file handle inheritable */
+ sa.nLength = sizeof(sa);
+ sa.lpSecurityDescriptor = NULL;
+ sa.bInheritHandle = TRUE;
+
+ hMixFile = CreateFileA( "fdopen.mix", GENERIC_READ|GENERIC_WRITE,
+ FILE_SHARE_READ | FILE_SHARE_WRITE, &sa, CREATE_ALWAYS, 0, NULL );
+ startup->dwFlags = STARTF_USESTDHANDLES;
+ startup->hStdInput = hMixFile;
+ startup->hStdOutput = hMixFile;
+ startup->hStdError = hMixFile;
+
+ CreateProcessA( NULL, cmdline, NULL, NULL, TRUE,
+ CREATE_DEFAULT_ERROR_MODE | NORMAL_PRIORITY_CLASS, NULL, NULL, startup, &proc );
+ winetest_wait_child_process( proc.hProcess );
+
+ data = read_file( hMixFile );
+ ok( !strcmp( data, "test1test2test3" ), "%s: Wrong error data (%s)\n", descr, data );
+
+ CloseHandle( hMixFile );
+ DeleteFileA( "fdopen.mix" );
+}
+
static void test_file_inherit( const char* selfname )
{
int fd;
test_stdout_handle( &startup, cmdline, handles[1], TRUE, "large size block" );
CloseHandle( handles[1] );
DeleteFileA("fdopen.tst");
+
+ /* test refcount of handles */
+ create_io_inherit_block( &startup, 0, NULL );
+ sprintf(cmdline, "%s file refcount", selfname);
+ test_file_refcount( &startup, cmdline, "file refcount" );
+ DeleteFileA("fdopen.tst");
}
static void test_tmpnam( void )
const char name[] = "empty1";
char buff[16];
unsigned char *ubuff = (unsigned char*)buff;
- FILE *file;
+ FILE *file, *file2;
int ret;
int len;
ubuff[0], ubuff[1], ubuff[2]);
fclose(file);
+ /* test initial FILE values */
+ memset(file, 0xfe, sizeof(*file));
+ file->_flag = 0;
+ ret = p_fopen_s(&file2, name, "r");
+ ok(!ret, "fopen_s failed with %d\n", ret);
+ ok(file == file2, "file != file2 %p %p\n", file, file2);
+ ok(!file->_ptr, "file->_ptr != NULL\n");
+ ok(!file->_cnt, "file->_cnt != 0\n");
+ ok(!file->_base, "file->_base != NULL\n");
+ ok(file->_flag == 1, "file->_flag = %x\n", file->_flag);
+ ok(file->_file, "file->_file == 0\n");
+ ok(file->_charbuf == 0xfefefefe, "file->_charbuf = %x\n", file->_charbuf);
+ ok(file->_bufsiz == 0xfefefefe, "file->_bufsiz = %x\n", file->_bufsiz);
+ ok(!file->_tmpfname, "file->_tmpfname != NULL\n");
+ fclose(file2);
+
ok(_unlink(name) == 0, "Couldn't unlink file named '%s'\n", name);
}
return;
}
+ errno = 0xdeadbeef;
+ ret = _setmode(-2, 0);
+ ok(ret == -1, "_setmode returned %x, expected -1\n", ret);
+ ok(errno == EINVAL, "errno = %d\n", errno);
+
+ errno = 0xdeadbeef;
+ ret = _setmode(-2, _O_TEXT);
+ ok(ret == -1, "_setmode returned %x, expected -1\n", ret);
+ ok(errno == EBADF, "errno = %d\n", errno);
+
fd = _open(name, _O_CREAT|_O_WRONLY, _S_IWRITE);
ok(fd != -1, "failed to open file\n");
_close(fd);
_unlink(fname);
+
+ errno = 0xdeadbeef;
+ handle = (HANDLE)_get_osfhandle(fd);
+ ok(handle == INVALID_HANDLE_VALUE, "_get_osfhandle returned %p\n", handle);
+ ok(errno == EBADF, "errno = %d\n", errno);
}
static void test_setmaxstdio(void)
CloseHandle(tmp);
}
+static void test_write_flush_size(FILE *file, int bufsize)
+{
+ char *inbuffer;
+ char *outbuffer;
+ int size, fd;
+ fpos_t pos, pos2;
+
+ fd = fileno(file);
+ inbuffer = calloc(bufsize + 1, 1);
+ outbuffer = calloc(bufsize + 1, 1);
+ _snprintf(outbuffer, bufsize + 1, "0,1,2,3,4,5,6,7,8,9");
+
+ for (size = bufsize + 1; size >= bufsize - 1; size--) {
+ rewind(file);
+ ok(file->_cnt == 0, "_cnt should be 0 after rewind, but is %d\n", file->_cnt);
+ fwrite(outbuffer, 1, size, file);
+ /* lseek() below intentionally redirects the write in fflush() to detect
+ * if fwrite() has already flushed the whole buffer or not.
+ */
+ lseek(fd, 1, SEEK_SET);
+ fflush(file);
+ ok(file->_cnt == 0, "_cnt should be 0 after fflush, but is %d\n", file->_cnt);
+ fseek(file, 0, SEEK_SET);
+ ok(fread(inbuffer, 1, bufsize, file) == bufsize, "read failed\n");
+ if (size == bufsize)
+ ok(memcmp(outbuffer, inbuffer, bufsize) == 0, "missing flush by %d byte write\n", size);
+ else
+ ok(memcmp(outbuffer, inbuffer, bufsize) != 0, "unexpected flush by %d byte write\n", size);
+ }
+ rewind(file);
+ fwrite(outbuffer, 1, bufsize / 2, file);
+ fwrite(outbuffer + bufsize / 2, 1, bufsize / 2, file);
+ lseek(fd, 1, SEEK_SET);
+ fflush(file);
+ fseek(file, 0, SEEK_SET);
+ ok(fread(inbuffer, 1, bufsize, file) == bufsize, "read failed\n");
+ ok(memcmp(outbuffer, inbuffer, bufsize) != 0, "unexpected flush by %d/2 byte double write\n", bufsize);
+
+ ok(!fseek(file, -1, SEEK_END), "fseek failed\n");
+ ok(!fgetpos(file, &pos), "fgetpos failed\n");
+ ok(fread(inbuffer, 1, 1, file) == 1, "fread failed\n");
+ ok(file->_flag & _IOREAD, "file->_flag = %x\n", file->_flag);
+ ok(!file->_cnt, "file->_cnt = %d\n", file->_cnt);
+ ok(file->_ptr != file->_base, "file->_ptr == file->_base\n");
+ ok(fwrite(outbuffer, 1, bufsize, file), "fwrite failed\n");
+ ok(file->_flag & _IOREAD, "file->_flag = %x\n", file->_flag);
+ ok(!file->_cnt, "file->_cnt = %d\n", file->_cnt);
+ ok(file->_ptr == file->_base, "file->_ptr == file->_base\n");
+ ok(!fgetpos(file, &pos2), "fgetpos failed\n");
+ ok(pos+bufsize+1 == pos2, "pos = %d (%d)\n", (int)pos, (int)pos2);
+ free(inbuffer);
+ free(outbuffer);
+}
+
+static void test_write_flush(void)
+{
+ char iobuf[1024];
+ char *tempf;
+ FILE *file;
+
+ tempf = _tempnam(".","wne");
+ file = fopen(tempf, "wb+");
+ ok(file != NULL, "unable to create test file\n");
+ iobuf[0] = 0;
+ ok(file->_bufsiz == 4096, "incorrect default buffer size: %d\n", file->_bufsiz);
+ test_write_flush_size(file, file->_bufsiz);
+ setvbuf(file, iobuf, _IOFBF, sizeof(iobuf));
+ test_write_flush_size(file, sizeof(iobuf));
+ fclose(file);
+ unlink(tempf);
+ free(tempf);
+}
+
START_TEST(file)
{
int arg_c;
test_file_inherit_child_no(arg_v[3]);
else if (strcmp(arg_v[2], "pipes") == 0)
test_pipes_child(arg_c, arg_v);
+ else if (strcmp(arg_v[2], "refcount") == 0)
+ test_file_refcount_child();
else
ok(0, "invalid argument '%s'\n", arg_v[2]);
return;
test_stdin();
test_mktemp();
test__open_osfhandle();
+ test_write_flush();
/* Wait for the (_P_NOWAIT) spawned processes to finish to make sure the report
* file contains lines in the correct order
projects / reactos.git / blobdiff