yamatanooroti 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3f7c72bc6c902dd8b5cdf5d02183954cba1180960c702e5642c208b074e2ccd5
+  data.tar.gz: d5dfea77ef4a055e0e278fa7447d96e1c473ce7aa4108062c99e3fc1d3e3d499
+SHA512:
+  metadata.gz: d4242ac34c419417a1e8035968b26f4587d6d5c332852a73dad9d413b0b06447b1cd0969272b344bd3bc4a26fc4934e2a156cfc740d44fe53344f4d1f130048a
+  data.tar.gz: 1f2679e02d8183d15c5ded5baa273d6ca1b4b299335145a4141066c3f315a0277623ca64caa1e0f5bdffe205280ce2b9b27cfe7b1f728c71e03f8293d7211b1c

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 aycabta
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,96 @@
+# Yamatanooroti
+
+Yamatanooroti is a multi-platform real(?) terminal testing framework.
+
+Supporting envronments:
+
+- vterm gem
+- Windows command prompt
+
+## Usage
+
+You can test the executed result and its rendering on the automatically detected environment that you have at the time, by code below:
+
+```ruby
+require 'yamatanooroti'
+
+class MyTest < Yamatanooroti::TestCase
+  def setup
+    start_terminal(5, 30, ['irb', '-f', '--multiline'])
+  end
+
+  def test_example
+    write(":a\n")
+    close
+    assert_screen(['irb(main):001:0> :a', '=> :a', 'irb(main):002:0>', '', ''])
+  end
+end
+```
+
+This code detects some real(?) terminal environments:
+
+- vterm gem (you should install beforehand)
+- Windows (you should run on command prompt)
+
+If any real(?) terminal environments not found, it will fail with a message:
+
+```
+$ rake
+Traceback (most recent call last):
+        (snip traceback)
+/path/to/yamatanooroti/lib/yamatanooroti.rb:71:in `inherited': Any real(?) terminal environments not found. (LoadError)
+Supporting real(?) terminals:
+- vterm gem
+- Windows
+rake aborted!
+Command failed with status (1)
+
+Tasks: TOP => default => test
+(See full trace by running task with --trace)
+```
+
+### Advanced Usage
+
+If you want to specify vterm environment that needs vterm gem, you can use `Yamatanooroti::VTermTestCase`:
+
+```ruby
+require 'yamatanooroti'
+
+class MyTest < Yamatanooroti::VTermTestCase
+  def setup
+    start_terminal(5, 30, ['irb', '-f', '--multiline'])
+  end
+
+  def test_example
+    write(":a\n")
+    close
+    assert_screen(['irb(main):001:0> :a', '=> :a', 'irb(main):002:0>', '', ''])
+  end
+end
+```
+
+If you haven't installed vterm gem, this code will fail with a message <q>You need vterm gem for Yamatanooroti::VTermTestCase (LoadError)</q>.
+
+Likewise, you can specify Windows command prompt test by `Yamatanooroti::WindowsTestCase`.
+
+## Method Reference
+
+### `start_terminal(height, width, command)`
+
+Starts terminal internally that is sized `height` and `width` with `command` to test the result. The `command` should be an array of strings with a path of command and zero or more options. This should be called in `setup` method.
+
+### `write(str)`
+
+Writes `str` like inputting by a keyboard to the started terminal.
+
+### `close`
+
+Closes the terminal to take the internal rendering result. You must call it before call assertions.
+
+### `assert_screen(expected_lines)`
+
+Asserts the rendering result of the terminal with `expected_lines` that should be an `Array` or a `String` of lines. The `Array` contains blank lines and doesn't contain newline characters, and the `String` contains newline characters at end of each line and doesn't contain continuous last blank lines.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/lib/yamatanooroti.rb

@@ -0,0 +1,89 @@
+require 'test-unit'
+
+class Yamatanooroti
+  def self.load_vterm
+    require 'vterm'
+    require 'yamatanooroti/vterm'
+  rescue LoadError
+    raise LoadError.new('You need vterm gem for Yamatanooroti::VTermTestCase')
+  end
+
+  def self.load_windows
+    unless win?
+      raise LoadError.new('You need Windows environment for Yamatanooroti::WindowsTestCase')
+    end
+    require 'yamatanooroti/windows'
+  end
+
+  def self.const_missing(id)
+    case id
+    when :VTermTestCase
+      load_vterm
+      Yamatanooroti::VTermTestCase
+    when :VTermTestCaseModule
+      load_vterm
+      Yamatanooroti::VTermTestCaseModule
+    when :WindowsTestCase
+      load_windows
+      Yamatanooroti::WindowsTestCase
+    when :WindowsTestCaseModule
+      load_windows
+      Yamatanooroti::WindowsTestCaseModule
+    else
+      raise StandardError.new("Unknown class #{id.to_s}")
+    end
+  end
+
+  def self.win?
+    RbConfig::CONFIG['host_os'].match?(/mswin|msys|mingw|cygwin|bccwin|wince|emc/)
+  end
+
+  def self.has_vterm_gem?
+    begin
+      require 'vterm'
+    rescue LoadError
+      false
+    else
+      true
+    end
+  end
+end
+
+class Yamatanooroti::TestCase < Test::Unit::TestCase
+  @@runners = []
+
+  def self.inherited(klass)
+    super
+    if ancestors.first == Yamatanooroti::TestCase
+      if Yamatanooroti.has_vterm_gem?
+        test_klass = Class.new(klass)
+        klass.const_set(:TestVTerm, test_klass)
+        test_klass.include Yamatanooroti::VTermTestCaseModule
+        @@runners << test_klass
+      end
+      if Yamatanooroti.win?
+        test_klass = Class.new(klass)
+        klass.const_set(:TestWindows, test_klass)
+        test_klass.include Yamatanooroti::WindowsTestCaseModule
+        @@runners << test_klass
+      end
+      if @@runners.empty?
+        raise LoadError.new(<<~EOM)
+          Any real(?) terminal environments not found.
+          Supporting real(?) terminals:
+          - vterm gem
+          - Windows
+        EOM
+      end
+      def klass.method_added(name)
+        super
+        if ancestors[1] == Yamatanooroti::TestCase
+          @@runners.each do |test_klass|
+            test_klass.define_method(name, instance_method(name))
+          end
+          remove_method name
+        end
+      end
+    end
+  end
+end

data/lib/yamatanooroti/version.rb

@@ -0,0 +1,3 @@
+class Yamatanooroti
+  VERSION = '0.0.1'
+end

data/lib/yamatanooroti/vterm.rb

@@ -0,0 +1,70 @@
+require 'test-unit'
+require 'vterm'
+require 'pty'
+
+module Yamatanooroti::VTermTestCaseModule
+  def start_terminal(height, width, command, wait: 0.1)
+    @wait = wait
+
+    @pty_output, @pty_input, @pid = PTY.spawn(*command)
+
+    @vterm = VTerm.new(height, width)
+    @vterm.set_utf8(true)
+
+    @screen = @vterm.screen
+    @screen.reset(true)
+
+    sync
+  end
+
+  def write(str)
+    sync
+    @pty_input.write(str)
+    sync
+  end
+
+  def close
+    sync
+    @pty_input.close
+    sync
+  end
+
+  private def sync
+    loop do
+      sleep @wait
+      chunk = @pty_output.read_nonblock(1024)
+      @vterm.write(chunk)
+      chunk = @vterm.read
+      @pty_input.write(chunk)
+    rescue Errno::EAGAIN, Errno::EWOULDBLOCK
+      break
+    rescue Errno::EIO # EOF
+      break
+    rescue IO::EAGAINWaitReadable # emtpy buffer
+      break
+    end
+  end
+
+  def assert_screen(expected_lines)
+    actual_lines = []
+    rows, cols = @vterm.size
+    rows.times do |r|
+      actual_lines << ''
+      cols.times do |c|
+        cell = @screen.cell_at(r, c)
+        actual_lines.last << cell.char if cell.char
+      end
+      actual_lines.last.gsub!(/ *$/, '')
+    end
+    case expected_lines
+    when Array
+      assert_equal(expected_lines, actual_lines)
+    when String
+      assert_equal(expected_lines, actual_lines.join("\n").sub(/\n*\z/, "\n"))
+    end
+  end
+end
+
+class Yamatanooroti::VTermTestCase < Test::Unit::TestCase
+  include Yamatanooroti::VTermTestCaseModule
+end

data/lib/yamatanooroti/windows.rb

@@ -0,0 +1,436 @@
+require 'test-unit'
+require 'fiddle/import'
+require 'fiddle/types'
+
+module Yamatanooroti::WindowsDefinition
+  extend Fiddle::Importer
+  dlload 'kernel32.dll', 'psapi.dll', 'user32.dll'
+  include Fiddle::Win32Types
+
+  FREE = Fiddle::Function.new(Fiddle::RUBY_FREE, [Fiddle::TYPE_VOIDP], Fiddle::TYPE_VOID)
+
+  typealias 'SHORT', 'short'
+  typealias 'HPCON', 'HANDLE'
+  typealias 'HPCON', 'HANDLE'
+  typealias 'HRESULT', 'HANDLE'
+  typealias 'LPVOID', 'void*'
+  typealias 'SIZE_T', 'size_t'
+  typealias 'LPWSTR', 'void*'
+  typealias 'LPBYTE', 'void*'
+  typealias 'LPCWSTR', 'void*'
+  typealias 'LPPROC_THREAD_ATTRIBUTE_LIST', 'void*'
+  typealias 'PSIZE_T', 'void*'
+  typealias 'DWORD_PTR', 'void*'
+  typealias 'LPCVOID', 'void*'
+  typealias 'LPDWORD', 'void*'
+  typealias 'LPOVERLAPPED', 'void*'
+  typealias 'WCHAR', 'SHORT'
+  typealias 'LPCWCH', 'void*'
+  typealias 'LPSTR', 'void*'
+  typealias 'LPCCH', 'void*'
+  typealias 'LPBOOL', 'void*'
+  typealias 'LPWORD', 'void*'
+  typealias 'ULONG_PTR', 'ULONG*'
+  typealias 'LONG', 'int'
+
+  Fiddle::SIZEOF_HANDLE = Fiddle::SIZEOF_LONG
+  Fiddle::SIZEOF_HPCON = Fiddle::SIZEOF_LONG
+  Fiddle::SIZEOF_HRESULT = Fiddle::SIZEOF_LONG
+  Fiddle::SIZEOF_DWORD = Fiddle::SIZEOF_LONG
+  Fiddle::SIZEOF_WORD = Fiddle::SIZEOF_SHORT
+
+  COORD = struct [
+    'SHORT X',
+    'SHORT Y'
+  ]
+  typealias 'COORD', 'DWORD32'
+
+  SMALL_RECT = struct [
+    'SHORT Left',
+    'SHORT Top',
+    'SHORT Right',
+    'SHORT Bottom'
+  ]
+  typealias 'SMALL_RECT*', 'DWORD64*'
+  typealias 'PSMALL_RECT', 'SMALL_RECT*'
+
+  SECURITY_ATTRIBUTES = struct [
+    'DWORD nLength',
+    'LPVOID lpSecurityDescriptor',
+    'BOOL bInheritHandle'
+  ]
+  typealias 'PSECURITY_ATTRIBUTES', 'SECURITY_ATTRIBUTES*'
+  typealias 'LPSECURITY_ATTRIBUTES', 'SECURITY_ATTRIBUTES*'
+
+  STARTUPINFOW = struct [
+    'DWORD cb',
+    'LPWSTR lpReserved',
+    'LPWSTR lpDesktop',
+    'LPWSTR lpTitle',
+    'DWORD dwX',
+    'DWORD dwY',
+    'DWORD dwXSize',
+    'DWORD dwYSize',
+    'DWORD dwXCountChars',
+    'DWORD dwYCountChars',
+    'DWORD dwFillAttribute',
+    'DWORD dwFlags',
+    'WORD wShowWindow',
+    'WORD cbReserved2',
+    'LPBYTE lpReserved2',
+    'HANDLE hStdInput',
+    'HANDLE hStdOutput',
+    'HANDLE hStdError'
+  ]
+  typealias 'LPSTARTUPINFOW', 'STARTUPINFOW*'
+
+  PROCESS_INFORMATION = struct [
+    'HANDLE hProcess',
+    'HANDLE hThread',
+    'DWORD  dwProcessId',
+    'DWORD  dwThreadId'
+  ]
+  typealias 'PPROCESS_INFORMATION', 'PROCESS_INFORMATION*'
+  typealias 'LPPROCESS_INFORMATION', 'PROCESS_INFORMATION*'
+
+  INPUT_RECORD_WITH_KEY_EVENT = struct [
+    'WORD EventType',
+    'BOOL bKeyDown',
+    'WORD wRepeatCount',
+    'WORD wVirtualKeyCode',
+    'WORD wVirtualScanCode',
+    'WCHAR UnicodeChar',
+    ## union 'CHAR  AsciiChar',
+    'DWORD dwControlKeyState'
+  ]
+
+  CHAR_INFO = struct [
+    'WCHAR UnicodeChar',
+    'WORD Attributes'
+  ]
+  typealias 'PCHAR_INFO', 'CHAR_INFO*'
+
+  PROCESSENTRY32W = struct [
+    'DWORD dwSize',
+    'DWORD cntUsage',
+    'DWORD th32ProcessID',
+    'ULONG_PTR th32DefaultHeapID',
+    'DWORD th32ModuleID',
+    'DWORD cntThreads',
+    'DWORD th32ParentProcessID',
+    'LONG pcPriClassBase',
+    'DWORD dwFlags',
+    'WCHAR szExeFile[260]'
+  ]
+  typealias 'LPPROCESSENTRY32W', 'PROCESSENTRY32W*'
+
+  CONSOLE_FONT_INFOEX = struct [
+    'ULONG cbSize',
+    'DWORD nFont',
+    'DWORD32 dwFontSize',
+    'UINT FontFamily',
+    'UINT FontWeight',
+    'WCHAR FaceName[32]'
+  ]
+  typealias 'PCONSOLE_FONT_INFOEX', 'CONSOLE_FONT_INFOEX*'
+
+  STD_INPUT_HANDLE = -10
+  STD_OUTPUT_HANDLE = -11
+  STD_ERROR_HANDLE = -12
+  ATTACH_PARENT_PROCESS = -1
+  KEY_EVENT = 0x0001
+  CT_CTYPE3 = 0x04
+  C3_HIRAGANA = 0x0020
+  C3_HALFWIDTH = 0x0040
+  C3_FULLWIDTH = 0x0080
+  C3_IDEOGRAPH = 0x0100
+  TH32CS_SNAPPROCESS = 0x00000002
+  PROCESS_ALL_ACCESS = 0x001FFFFF
+
+  # HANDLE GetStdHandle(DWORD nStdHandle);
+  extern 'HANDLE GetStdHandle(DWORD);', :stdcall
+  # BOOL CloseHandle(HANDLE hObject);
+  extern 'BOOL CloseHandle(HANDLE);', :stdcall
+
+  # BOOL FreeConsole(void);
+  extern 'BOOL FreeConsole(void);', :stdcall
+  # BOOL AllocConsole(void);
+  extern 'BOOL AllocConsole(void);', :stdcall
+  # BOOL AttachConsole(DWORD dwProcessId);
+  extern 'BOOL AttachConsole(DWORD);', :stdcall
+  # BOOL WINAPI SetConsoleScreenBufferSize(HANDLE hConsoleOutput, COORD dwSize);
+  extern 'BOOL SetConsoleScreenBufferSize(HANDLE, COORD);', :stdcall
+  # BOOL WINAPI SetConsoleWindowInfo(HANDLE hConsoleOutput, BOOL bAbsolute, const SMALL_RECT *lpConsoleWindow);
+  extern 'BOOL SetConsoleWindowInfo(HANDLE, BOOL, PSMALL_RECT);', :stdcall
+  # BOOL WriteConsoleInputW(HANDLE hConsoleInput, const INPUT_RECORD *lpBuffer, DWORD nLength, LPDWORD lpNumberOfEventsWritten);
+  extern 'BOOL WriteConsoleInputW(HANDLE, const INPUT_RECORD*, DWORD, LPDWORD);', :stdcall
+  # BOOL ReadConsoleOutputW(HANDLE hConsoleOutput, PCHAR_INFO lpBuffer, COORD dwBufferSize, COORD dwBufferCoord, PSMALL_RECT lpReadRegion);
+  extern 'BOOL ReadConsoleOutputW(HANDLE, PCHAR_INFO, COORD, COORD, PSMALL_RECT);', :stdcall
+  # BOOL WINAPI SetCurrentConsoleFontEx(HANDLE hConsoleOutput, BOOL bMaximumWindow, PCONSOLE_FONT_INFOEX lpConsoleCurrentFontEx);
+  extern 'BOOL SetCurrentConsoleFontEx(HANDLE, BOOL, PCONSOLE_FONT_INFOEX);', :stdcall
+
+  # BOOL CreateProcessW(LPCWSTR lpApplicationName, LPWSTR lpCommandLine, LPSECURITY_ATTRIBUTES lpProcessAttributes, LPSECURITY_ATTRIBUTES lpThreadAttributes, BOOL bInheritHandles, DWORD dwCreationFlags, LPVOID lpEnvironment, LPCWSTR lpCurrentDirectory, LPSTARTUPINFOW lpStartupInfo, LPPROCESS_INFORMATION lpProcessInformation);
+  extern 'BOOL CreateProcessW(LPCWSTR lpApplicationName, LPWSTR lpCommandLine, LPSECURITY_ATTRIBUTES lpProcessAttributes, LPSECURITY_ATTRIBUTES lpThreadAttributes, BOOL bInheritHandles, DWORD dwCreationFlags, LPVOID lpEnvironment, LPCWSTR lpCurrentDirectory, LPSTARTUPINFOW lpStartupInfo, LPPROCESS_INFORMATION lpProcessInformation);', :stdcall
+  # HANDLE CreateToolhelp32Snapshot(DWORD dwFlags, DWORD th32ProcessID);
+  extern 'HANDLE CreateToolhelp32Snapshot(DWORD, DWORD);', :stdcall
+  # BOOL Process32First(HANDLE hSnapshot, LPPROCESSENTRY32W lppe);
+  extern 'BOOL Process32FirstW(HANDLE, LPPROCESSENTRY32W);', :stdcall
+  # BOOL Process32Next(HANDLE hSnapshot, LPPROCESSENTRY32 lppe);
+  extern 'BOOL Process32NextW(HANDLE, LPPROCESSENTRY32W);', :stdcall
+  # DWORD GetCurrentProcessId();
+  extern 'DWORD GetCurrentProcessId();', :stdcall
+  # HANDLE OpenProcess(DWORD dwDesiredAccess, BOOL bInheritHandle, DWORD dwProcessId);
+  extern 'HANDLE OpenProcess(DWORD, BOOL, DWORD);', :stdcall
+  # BOOL TerminateProcess(HANDLE hProcess, UINT uExitCode);
+  extern 'BOOL TerminateProcess(HANDLE, UINT);', :stdcall
+  #BOOL TerminateThread(HANDLE hThread, DWORD dwExitCode);
+  extern 'BOOL TerminateThread(HANDLE, DWORD);', :stdcall
+
+  # int MultiByteToWideChar(UINT CodePage, DWORD dwFlags, LPCSTR lpMultiByteStr, int cbMultiByte, LPWSTR lpWideCharStr, int cchWideChar);
+  extern 'int MultiByteToWideChar(UINT, DWORD, LPCSTR, int, LPWSTR, int);', :stdcall
+  # int WideCharToMultiByte(UINT CodePage, DWORD dwFlags, _In_NLS_string_(cchWideChar)LPCWCH lpWideCharStr, int cchWideChar, LPSTR lpMultiByteStr, int cbMultiByte, LPCCH lpDefaultChar, LPBOOL lpUsedDefaultChar);
+  extern 'int WideCharToMultiByte(UINT, DWORD, LPCWCH, int, LPSTR, int, LPCCH, LPBOOL);', :stdcall
+  #BOOL GetStringTypeW(DWORD dwInfoType, LPCWCH lpSrcStr, int cchSrc, LPWORD lpCharType);
+  extern 'BOOL GetStringTypeW(DWORD, LPCWCH, int, LPWORD);', :stdcall
+
+  typealias 'LPTSTR', 'void*'
+  typealias 'HLOCAL', 'HANDLE'
+  extern 'DWORD FormatMessage(DWORD dwFlags, LPCVOID lpSource, DWORD dwMessageId, DWORD dwLanguageId, LPTSTR lpBuffer, DWORD nSize, va_list *Arguments);', :stdcall
+  extern 'HLOCAL LocalFree(HLOCAL hMem);', :stdcall
+  extern 'DWORD GetLastError();', :stdcall
+  FORMAT_MESSAGE_ALLOCATE_BUFFER = 0x00000100
+  FORMAT_MESSAGE_FROM_SYSTEM = 0x00001000
+  LANG_NEUTRAL = 0x00
+  SUBLANG_DEFAULT = 0x01
+  extern 'int GetSystemMetrics(int);', :stdcall
+  SM_CXMIN = 28
+  SM_CYMIN = 29
+end
+
+module Yamatanooroti::WindowsTestCaseModule
+  DL = Yamatanooroti::WindowsDefinition
+
+  private def setup_console(height, width)
+
+    result = DL.FreeConsole
+    error_message(result, 'FreeConsole')
+    result = DL.AllocConsole
+    error_message(result, 'AllocConsole')
+    @output_handle = DL.GetStdHandle(DL::STD_OUTPUT_HANDLE)
+
+=begin
+    font = DL::CONSOLE_FONT_INFOEX.malloc
+    (font.to_ptr + 0)[0, DL::CONSOLE_FONT_INFOEX.size] = "\x00" * DL::CONSOLE_FONT_INFOEX.size
+    font.cbSize = DL::CONSOLE_FONT_INFOEX.size
+    font.nFont = 0
+    font_size = 72
+    font.dwFontSize = font_size * 65536 + font_size
+    font.FontFamily = 0
+    font.FontWeight = 0
+    font.FaceName[0] = "\x00".ord
+    result = DL.SetCurrentConsoleFontEx(@output_handle, 0, font)
+    error_message(result, 'SetCurrentConsoleFontEx')
+=end
+
+    rect = DL::SMALL_RECT.malloc
+    rect.Left = 0
+    rect.Top = 0
+    rect.Right = width - 1
+    rect.Bottom = height - 1
+    result = DL.SetConsoleWindowInfo(@output_handle, 1, rect)
+    error_message(result, 'SetConsoleWindowInfo')
+
+    size = DL.GetSystemMetrics(DL::SM_CYMIN) * 65536 + DL.GetSystemMetrics(DL::SM_CXMIN)
+    result = DL.SetConsoleScreenBufferSize(@output_handle, size)
+    error_message(result, 'SetConsoleScreenBufferSize')
+
+    size = height * 65536 + width
+    result = DL.SetConsoleScreenBufferSize(@output_handle, size)
+    error_message(result, 'SetConsoleScreenBufferSize')
+  end
+
+  private def mb2wc(str)
+    size = DL.MultiByteToWideChar(65001, 0, str, str.bytesize, '', 0)
+    converted_str = String.new("\x00" * (size * 2), encoding: 'ASCII-8BIT')
+    DL.MultiByteToWideChar(65001, 0, str, str.bytesize, converted_str, converted_str.bytesize)
+    converted_str
+  end
+
+  private def wc2mb(str)
+    size = DL.WideCharToMultiByte(65001, 0, str, str.bytesize, '', 0, 0, 0)
+    converted_str = "\x00" * (size * 2)
+    DL.WideCharToMultiByte(65001, 0, str, str.bytesize, converted_str, converted_str.bytesize, 0, 0)
+    converted_str
+  end
+
+  private def full_width?(c)
+    return false if c.nil? or c.empty?
+    wc = mb2wc(c)
+    type = Fiddle::Pointer.malloc(Fiddle::SIZEOF_WORD, DL::FREE)
+    DL.GetStringTypeW(DL::CT_CTYPE3, wc, wc.bytesize, type)
+    char_type = type[0, Fiddle::SIZEOF_WORD].unpack('S').first
+    if char_type.anybits?(DL::C3_FULLWIDTH)
+      true
+    elsif char_type.anybits?(DL::C3_HALFWIDTH)
+      false
+    elsif char_type.anybits?(DL::C3_HIRAGANA)
+      true
+    elsif char_type.anybits?(DL::C3_IDEOGRAPH)
+      true
+    else
+      false
+    end
+  end
+
+  private def launch(command)
+    command = %Q{cmd.exe /q /c "#{command.gsub('"', '\\"')}"}
+    converted_command = mb2wc(command)
+    @pi = DL::PROCESS_INFORMATION.malloc
+    (@pi.to_ptr + 0)[0, DL::PROCESS_INFORMATION.size] = "\x00" * DL::PROCESS_INFORMATION.size
+    @startup_info_ex = DL::STARTUPINFOW.malloc
+    (@startup_info_ex.to_ptr + 0)[0, DL::STARTUPINFOW.size] = "\x00" * DL::STARTUPINFOW.size
+    result = DL.CreateProcessW(
+      Fiddle::NULL, converted_command,
+      Fiddle::NULL, Fiddle::NULL, 0, 0, Fiddle::NULL, Fiddle::NULL,
+      @startup_info_ex, @pi
+    )
+    error_message(result, 'CreateProcessW')
+    sleep @wait
+  rescue => e
+    pp e
+  end
+
+  private def error_message(result, method_name)
+    return if not result.zero?
+    err = DL.GetLastError
+    string = Fiddle::Pointer.malloc(Fiddle::SIZEOF_VOIDP)
+    DL.FormatMessage(
+      DL::FORMAT_MESSAGE_ALLOCATE_BUFFER | DL::FORMAT_MESSAGE_FROM_SYSTEM,
+      Fiddle::NULL,
+      err,
+      0x0,
+      string,
+      0,
+      Fiddle::NULL
+    )
+    log "ERROR(#{method_name}): #{err.to_s}: #{string.ptr.to_s}"
+    DL.LocalFree(string)
+  end
+
+  private def log(str)
+    puts str
+    open('aaa', 'a') do |fp|
+      fp.puts str
+    end
+  end
+
+  def write(str)
+    sleep @wait
+    str.tr!("\n", "\r")
+    records = Fiddle::Pointer.malloc(DL::INPUT_RECORD_WITH_KEY_EVENT.size * str.size * 2, DL::FREE)
+    str.chars.each_with_index do |c, i|
+      record_index = i * 2
+      r = DL::INPUT_RECORD_WITH_KEY_EVENT.new(records + DL::INPUT_RECORD_WITH_KEY_EVENT.size * record_index)
+      r.EventType = DL::KEY_EVENT
+      r.bKeyDown = 1
+      r.wRepeatCount = 0
+      r.wVirtualKeyCode = 0
+      r.wVirtualScanCode = 0
+      r.UnicodeChar = c.unpack('U').first
+      r.dwControlKeyState = 0
+      record_index = i * 2 + 1
+      r = DL::INPUT_RECORD_WITH_KEY_EVENT.new(records + DL::INPUT_RECORD_WITH_KEY_EVENT.size * record_index)
+      r.EventType = DL::KEY_EVENT
+      r.bKeyDown = 0
+      r.wRepeatCount = 0
+      r.wVirtualKeyCode = 0
+      r.wVirtualScanCode = 0
+      r.UnicodeChar = c.unpack('U').first
+      r.dwControlKeyState = 0
+    end
+    written_size = Fiddle::Pointer.malloc(Fiddle::SIZEOF_DWORD, DL::FREE)
+    result = DL.WriteConsoleInputW(DL.GetStdHandle(DL::STD_INPUT_HANDLE), records, str.size * 2, written_size)
+    error_message(result, 'WriteConsoleInput')
+  end
+
+  private def free_resources
+    h_snap = DL.CreateToolhelp32Snapshot(DL::TH32CS_SNAPPROCESS, 0)
+    pe = DL::PROCESSENTRY32W.malloc
+    (pe.to_ptr + 0)[0, DL::PROCESSENTRY32W.size] = "\x00" * DL::PROCESSENTRY32W.size
+    pe.dwSize = DL::PROCESSENTRY32W.size
+    result = DL.Process32FirstW(h_snap, pe)
+    error_message(result, "Process32First")
+    result = DL.FreeConsole()
+    #error_message(result, "FreeConsole")
+    result = DL.AttachConsole(DL::ATTACH_PARENT_PROCESS)
+    error_message(result, 'AttachConsole')
+    loop do
+      #log "a #{pe.th32ParentProcessID.inspect} -> #{pe.th32ProcessID.inspect} #{wc2mb(pe.szExeFile.pack('S260')).unpack('Z*').pack('Z*')}"
+      if pe.th32ParentProcessID == DL.GetCurrentProcessId
+        h_child_proc = DL.OpenProcess(DL::PROCESS_ALL_ACCESS, 0, pe.th32ProcessID)
+        if (h_child_proc)
+          result = DL.TerminateProcess(h_child_proc, 0)
+          error_message(result, "TerminateProcess")
+          result = DL.CloseHandle(h_child_proc)
+          error_message(result, "CloseHandle")
+        end
+      end
+      break if DL.Process32NextW(h_snap, pe).zero?
+    end
+    result = DL.TerminateThread(@pi.hThread, 0)
+    error_message(result, "TerminateThread")
+  end
+
+  def close
+    sleep @wait
+    # read first before kill the console process including output
+    char_info_matrix = Fiddle::Pointer.to_ptr("\x00" * (DL::CHAR_INFO.size * (@height * @width)))
+    region = DL::SMALL_RECT.malloc
+    region.Left = 0
+    region.Top = 0
+    region.Right = @width
+    region.Bottom = @height
+    result = DL.ReadConsoleOutputW(@output_handle, char_info_matrix, @height * 65536 + @width, 0, region)
+    error_message(result, "ReadConsoleOutputW")
+    @result = []
+    prev_c = nil
+    @height.times do |y|
+      line = ''
+      @width.times do |x|
+        index = @width * y + x
+        char_info = DL::CHAR_INFO.new(char_info_matrix + DL::CHAR_INFO.size * index)
+        mb = [char_info.UnicodeChar].pack('U')
+        if prev_c == mb and full_width?(mb)
+          prev_c = nil
+        else
+          line << mb
+          prev_c = mb
+        end
+      end
+      @result << line.gsub(/ *$/, '')
+    end
+
+    free_resources
+  end
+
+  def assert_screen(expected_lines)
+    case expected_lines
+    when Array
+      assert_equal(expected_lines, @result)
+    when String
+      assert_equal(expected_lines, @result.join("\n").sub(/\n*\z/, "\n"))
+    end
+  end
+
+  def start_terminal(height, width, command, wait: 1)
+    @height = height
+    @width = width
+    @wait = wait
+    setup_console(height, width)
+    launch(command.join(' '))
+  end
+end
+
+class Yamatanooroti::WindowsTestCase < Test::Unit::TestCase
+  include Yamatanooroti::WindowsTestCaseModule
+end

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification
+name: yamatanooroti
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- aycabta
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2020-03-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: "    Yamatanooroti is a multi-platform real(?) terminal test framework.\n"
+email:
+- aycabta@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/yamatanooroti.rb
+- lib/yamatanooroti/version.rb
+- lib/yamatanooroti/vterm.rb
+- lib/yamatanooroti/windows.rb
+homepage: https://github.com/aycabta/yamatanooroti
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.5'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: Multi-platform real(?) terminal test framework
+test_files: []