fzeet 0.6.5 → 0.6.6

data/LICENSE_CEF

@@ -0,0 +1,29 @@
+// Copyright (c) 2008-2010 Marshall A. Greenblatt. Portions Copyright (c)
+// 2006-2010 Google Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/checks/Bstr.rb

@@ -0,0 +1,14 @@
+require 'fzeet'
+
+include Fzeet
+
+Bstr['foo'].tap { |bstr|
+	raise unless bstr.length == 3
+	raise unless bstr.multibyte == 'foo'
+
+	bstr.dispose
+}
+
+raise unless Bstr.from('foo') { |bstr|
+	raise unless bstr.length == 3
+}.nil?

data/checks/Decimal.rb

@@ -0,0 +1,27 @@
+require 'fzeet'
+
+include Fzeet
+
+Decimal[42].tap { |decimal|
+	raise unless decimal.int == 42
+}
+
+Decimal[-42].tap { |decimal|
+	raise unless decimal.int == -42
+}
+
+Decimal[0x7fff_ffff_ffff_ffff].tap { |decimal|
+	raise unless decimal.longlong == 0x7fff_ffff_ffff_ffff
+}
+
+Decimal[-0x7fff_ffff_ffff_ffff].tap { |decimal|
+	raise unless decimal.longlong == -0x7fff_ffff_ffff_ffff
+}
+
+Decimal[1.1].tap { |decimal|
+	raise unless decimal.double == 1.1
+}
+
+Decimal[-1.1].tap { |decimal|
+	raise unless decimal.double == -1.1
+}

data/checks/OSVERSIONINFOEX.rb

@@ -0,0 +1,14 @@
+require 'fzeet'
+
+include Fzeet
+
+Windows::OSVERSIONINFOEX.new.tap { |ovi|
+	ovi[:dwMajorVersion] = 5
+	ovi[:dwMinorVersion] = 2
+
+	raise unless ovi.hex == 0x0502
+	raise unless ovi >= :xp
+	raise unless ovi > 2000
+	raise unless ovi < :vista
+	raise unless ovi.name == 'Windows XP'
+}

data/checks/Point.rb

@@ -0,0 +1,65 @@
+require 'fzeet'
+
+include Fzeet
+
+# Point.[], Point#to_a
+raise unless Point[42, 43].to_a == [42, 43]
+
+# Point#wrap, Point#==
+Point[42, 43].tap { |pt|
+	Point.wrap(pt.pointer).tap { |pt1|
+		raise unless pt.pointer == pt1.pointer # same pointer
+		raise if pt.equal?(pt1) # different objects
+		raise unless pt == pt1 # same coords
+
+		pt1[:x] += 2
+	}
+
+	raise unless pt[:x] == 44
+}
+
+# Point#dup
+Point[42, 43].tap { |pt|
+	pt.dup.tap { |pt1|
+		raise if pt.pointer == pt1.pointer # different pointers
+		raise if pt.equal?(pt1) # different objects
+		raise unless pt == pt1 # same coords
+
+		pt1[:x] += 2
+	}
+
+	raise unless pt[:x] == 42
+}
+
+# Point#get, Point#set, Point#clear
+Point[42, 43].tap { |pt|
+	raise unless pt.set(1, 2).get == [1, 2]
+	raise unless pt.clear.get == [0, 0]
+}
+
+# Point#inside?, Point#outside?
+Rect[100, 200, 300, 400].tap { |r|
+	raise unless Point[100, 200].inside?(r)
+	raise unless Point[299, 399].inside?(r)
+	raise if Point[300, 400].inside?(r) # rigth-bottom corner is excluded
+	raise unless Point[300, 400].outside?(r)
+}
+
+# Point#offset, Point#offset!
+Point[42, 43].tap { |pt|
+	raise if pt.equal?(pt.offset(10, 20))
+	raise unless pt.offset!(10, 20).to_a == [52, 63]
+	raise unless pt.offset!(-10, -20).to_a == [42, 43]
+}
+
+# Point#client, Point#client!, Point#screen, Point#screen!
+Window.new(x: 100, y: 200).tap { |window|
+	Point[100, 200].tap { |screen|
+		raise if screen.equal?(screen.client(window))
+		screen.client!(window).tap { |client|
+			raise if client.equal?(client.screen(window))
+			raise unless client.to_a.all? { |coord| coord < 0 }
+			raise unless client.screen!(window).to_a == [100, 200]
+		}
+	}
+}

data/checks/Rect.rb

@@ -0,0 +1,104 @@
+require 'fzeet'
+
+include Fzeet
+
+# Rect.[](left, top, right, bottom), Rect#to_a
+raise unless Rect[100, 200, 300, 400].to_a == [100, 200, 300, 400]
+
+# Rect.[](location, size)
+raise unless Rect[Point[100, 200], Size[200, 200]].to_a == [100, 200, 300, 400]
+
+# Rect#wrap, Rect#==
+Rect[100, 200, 300, 400].tap { |r|
+	Rect.wrap(r.pointer).tap { |r1|
+		raise unless r.pointer == r1.pointer # same pointer
+		raise if r.equal?(r1) # different objects
+		raise unless r == r1 # same coords
+
+		r1[:left] += 50
+	}
+
+	raise unless r[:left] == 150
+}
+
+# Rect#dup
+Rect[100, 200, 300, 400].tap { |r|
+	r.dup.tap { |r1|
+		raise if r.pointer == r1.pointer # different pointers
+		raise if r.equal?(r1) # different objects
+		raise unless r == r1 # same coords
+
+		r1[:left] += 50
+	}
+
+	raise unless r[:left] == 100
+}
+
+# Rect#get, Rect#set, Rect#clear, Rect#empty?
+Rect[100, 200, 300, 400].tap { |r|
+	raise unless r.set(1, 2, 3, 4).get == [1, 2, 3, 4]
+	raise if r.empty?
+	raise unless r.clear.get == [0, 0, 0, 0]
+	raise unless r.empty?
+}
+
+# Rect#lt, Rect#lt=, Rect#lb, Rect#lb=, Rect#rt, Rect#rt=, Rect#rb, Rect#rb=
+# Rect#width, Rect#width=, Rect#height, Rect#height=, Rect#size, Rect#size=
+# Rect#structSize
+Rect[100, 200, 300, 400].tap { |r|
+	raise unless r.lt.to_a == [100, 200]
+	raise unless r.lb.to_a == [100, 400]
+	raise unless r.rt.to_a == [300, 200]
+	raise unless r.rb.to_a == [300, 400]
+
+	raise unless r.location.to_a == [100, 200]
+	raise unless r.size.to_a == [200, 200]
+
+	r.location = Point[1, 2]
+	r.size = Size[3, 4]
+
+	raise unless r.to_a == [1, 2, 4, 6]
+
+	raise unless r.structSize == 16
+}
+
+# Rect#include?, Rect#exclude?
+Rect[100, 200, 300, 400].tap { |r|
+	raise unless r.include?(Point[100, 200])
+	raise unless r.include?(Point[299, 399])
+	raise if r.include?(Point[300, 400]) # rigth-bottom corner is excluded
+	raise unless r.exclude?(Point[300, 400])
+
+	raise unless r.include?(Rect[100, 200, 299, 399])
+	raise unless r.include?(Rect[100, 200, 299, 399], Point[299, 399])
+}
+
+# Rect#normalized?, Rect#normalize, Point#normalize!
+Rect[300, 400, 100, 200].tap { |r|
+	raise if r.equal?(r.normalize)
+	raise if r.normalized?
+	raise unless r.normalize!.to_a == [100, 200, 300, 400]
+	raise unless r.normalized?
+}
+
+# Rect#offset, Rect#offset!, Rect#inflate, Rect#inflate!
+Rect[100, 200, 300, 400].tap { |r|
+	raise if r.equal?(r.offset(10, 20))
+	raise unless r.offset!(10, 20).to_a == [110, 220, 310, 420]
+	raise unless r.offset!(-10, -20).to_a == [100, 200, 300, 400]
+
+	raise if r.equal?(r.inflate(10, 20))
+	raise unless r.inflate!(10, 20).to_a == [90, 180, 310, 420]
+	raise unless r.inflate!(-10, -20).to_a == [100, 200, 300, 400]
+}
+
+# Rect#|, Rect#&, Rect#-
+[Rect[100, 200, 300, 400], Rect[110, 220, 310, 420]].tap { |r1, r2|
+	raise unless (r1 | r2).to_a == [100, 200, 310, 420]
+
+	raise unless (r1 & r2).to_a == [110, 220, 300, 400]
+
+	raise unless r1 - r2 == r1
+	r2[:top] = 200
+	raise unless (r1 - r2).to_a == [100, 200, 110, 400]
+}

data/checks/RunAll.rb

@@ -0,0 +1,2 @@
+Dir["#{File.dirname(path = File.expand_path(__FILE__))}/*.rb"].
+	each { |check| next if check == path; require check }

data/checks/SafeArray.rb

@@ -0,0 +1,27 @@
+require 'fzeet'
+
+include Fzeet
+
+SafeArray.vector(2).tap { |sa|
+	raise unless sa[:cDims] == 1
+	raise unless sa.length == 2
+	raise unless sa.vt == Windows::VT_VARIANT
+
+	sa[0] = Variant[:int, 42]
+	raise unless sa[0].int == 42
+
+	sa[1] = Variant[:bstr, 'foo']
+	raise unless sa[1].bstr == 'foo'
+
+	sa.dispose
+}
+
+raise unless SafeArray.vector(2) { |sa|
+	raise unless sa.length == 2
+}.nil?
+
+SafeArray.vector(5) { |sa|
+	(1..5).each.with_index { |v, i| sa[i] = Variant[:int, v] }
+
+	raise unless sa.inject(1) { |product, variant| product *= variant.int } == 120
+}

data/checks/Size.rb

@@ -0,0 +1,45 @@
+require 'fzeet'
+
+include Fzeet
+
+# Size.[], Size#to_a
+raise unless Size[42, 43].to_a == [42, 43]
+
+# Size#wrap, Size#==
+Size[42, 43].tap { |s|
+	Size.wrap(s.pointer).tap { |s1|
+		raise unless s.pointer == s1.pointer # same pointer
+		raise if s.equal?(s1) # different objects
+		raise unless s == s1 # same lengths
+
+		s1[:cx] += 2
+	}
+
+	raise unless s[:cx] == 44
+}
+
+# Size#dup
+Size[42, 43].tap { |s|
+	s.dup.tap { |s1|
+		raise if s.pointer == s1.pointer # different pointers
+		raise if s.equal?(s1) # different objects
+		raise unless s == s1 # same lengths
+
+		s1[:cx] += 2
+	}
+
+	raise unless s[:cx] == 42
+}
+
+# Size#get, Size#set, Size#clear
+Size[42, 43].tap { |s|
+	raise unless s.set(1, 2).get == [1, 2]
+	raise unless s.clear.get == [0, 0]
+}
+
+# Size#inflate, Size#inflate!
+Size[42, 43].tap { |s|
+	raise if s.equal?(s.inflate(10, 20))
+	raise unless s.inflate!(10, 20).to_a == [52, 63]
+	raise unless s.inflate!(-10, -20).to_a == [42, 43]
+}

data/checks/SystemTime.rb

@@ -0,0 +1,43 @@
+require 'fzeet'
+
+include Fzeet
+
+# SystemTime.[], SystemTime#get
+SystemTime[Time.local(2000, 3, 4, 5, 6, 7, 8.9 * 1000)].tap { |st|
+	local = st.get
+
+	raise unless local.year == 2000
+	raise unless local.month == 3
+	raise unless local.day == 4
+	raise unless local.hour == 5
+	raise unless local.min == 6
+	raise unless local.sec == 7
+	raise unless st[:wMilliseconds] == 9
+	raise unless local.usec == 9000
+}
+
+# SystemTime#wrap, SystemTime#==
+SystemTime[Time.local(2000, 3, 4)].tap { |st|
+	SystemTime.wrap(st.pointer).tap { |st1|
+		raise unless st.pointer == st1.pointer # same pointer
+		raise if st.equal?(st1) # different objects
+		raise unless st == st1 # same time
+
+		st1[:wYear] += 10
+	}
+
+	raise unless st[:wYear] == 2010
+}
+
+# SystemTime#dup
+SystemTime[Time.local(2000, 3, 4)].tap { |st|
+	st.dup.tap { |st1|
+		raise if st.pointer == st1.pointer # different pointers
+		raise if st.equal?(st1) # different objects
+		raise unless st == st1 # same time
+
+		st1[:wYear] += 10
+	}
+
+	raise unless st[:wYear] == 2000
+}

data/checks/Variant.rb

@@ -0,0 +1,160 @@
+require 'fzeet'
+
+include Fzeet
+
+Variant[:bool, true].tap { |variant|
+	raise unless variant.bool == true
+	variant.bool = false
+	raise unless variant.bool == false
+}
+
+Variant[:bool, false].tap { |variant|
+	raise unless variant.bool == false
+	variant.bool = true
+	raise unless variant.bool == true
+}
+
+Variant[:bool, false].tap { |variant|
+	variant.clear
+
+	begin
+		variant.bool
+	rescue
+	else
+		raise
+	end
+}
+
+Variant[:byte, 255].tap { |variant|
+	raise unless variant.byte == 255
+}
+
+Variant[:char, 255].tap { |variant|
+	raise unless variant.char == -1
+}
+
+Variant[:qword, 0xdead_beef_feeb_daed].tap { |variant|
+	raise unless variant.qword >> 32 == 0xdead_beef
+}
+
+Variant[:float, 1.1].tap { |variant|
+	#raise unless variant.float == 1.1
+	raise unless variant.float - 1.1 < 0.000_000_1
+}
+
+Variant[:double, 1.1].tap { |variant|
+	raise unless variant.double == 1.1
+}
+
+Variant[:string, 'foo'].tap { |variant|
+	raise unless variant.string == 'foo'
+
+	variant.clear
+}
+
+Variant[:date, Time.local(2000, 3, 4, 5, 6, 7)].tap { |variant|
+	local = variant.date
+
+	raise unless local.year == 2000
+	raise unless local.month == 3
+	raise unless local.day == 4
+	raise unless local.hour == 5
+	raise unless local.min == 6
+	raise unless local.sec == 7
+}
+
+Variant[:decimal, 42].tap { |variant|
+	raise unless variant.decimal == 42
+}
+
+Variant[:decimal, -42].tap { |variant|
+	raise unless variant.decimal == -42
+}
+
+Variant[:decimal, 1.1].tap { |variant|
+	raise unless variant.decimal == 1.1
+}
+
+Variant[:decimal, -1.1].tap { |variant|
+	raise unless variant.decimal == -1.1
+}
+
+IFoo = Windows::COM::Interface[Windows::IDispatch,
+	Windows::GUID['00000000-0000-0000-0000-000000000042'],
+
+	value: [[], :int]
+]
+
+Foo = Windows::COM::Callback[IFoo]
+
+class Foo
+	def value; 42 end
+end
+
+Foo.new.tap { |foo|
+	raise unless foo.refc == 1
+
+	Variant[:dispatch, foo].tap { |variant|
+		raise unless foo.refc == 2
+
+		dispatch = variant.dispatch
+
+		raise unless foo.refc == 3
+
+		dispatch.QueryInstance(Foo) { |instance|
+			raise unless foo.refc == 4
+
+			raise unless instance.value == 42
+		}.Release
+
+		raise unless foo.refc == 3
+
+		dispatch.Release
+
+		raise unless foo.refc == 2
+
+		variant.clear
+
+		raise unless foo.refc == 1
+	}
+
+	foo.Release
+
+	raise unless foo.refc == 0
+}
+
+Variant[:array, SafeArray.vector(2)].tap { |variant|
+	array = variant.array
+
+	array.
+		put(0, Variant[:int, 42]).
+		put(1, Variant[:array, SafeArray.vector(2).
+			put(0, Variant[:int, 43]).
+			put(1, Variant[:bstr, 'foo'])
+		])
+
+	raise unless array[0].int == 42
+	raise unless array[1].array[0].int == 43
+	raise unless array[1].array[1].bstr == 'foo'
+
+	variant.clear
+}
+
+FFI::MemoryPointer.new(:int) { |pint|
+	pint.write_int(0xc0ffee)
+
+	Variant[:byref, pint].tap { |variant|
+		raise unless variant.byref.address == pint.address
+		raise unless variant.byref(:int) == 0xc0ffee
+	}
+}
+
+Decimal[1.1].tap { |decimal|
+	Variant[:byref, decimal].tap { |variant|
+		raise unless Decimal.new(variant.byref).double == 1.1
+	}
+}
+
+Variant[:object, [1, 2, 3, 4, 5]].tap { |variant|
+	raise unless variant.object.inject(:+) == 15
+}