overflow 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: da45bcd93d214011fe0426b29f28127b9db55af8
+  data.tar.gz: ab817a7f4ccfbe748cb8911ed5ce11acd0d37c86
+SHA512:
+  metadata.gz: 94ab24a96c978d9f1d556109114b2177fdcd9c9ba84c24a23d23dde617b7db169ad516419a197fe7e254724595c1b8cec426b55fa7ee087b008d974b5f2fb9a9
+  data.tar.gz: 22cc6db2db596113391d75120589109e96b201361cdc02cb558f17063248ea62e93f61da1798b0ab0495543b236845cad1f2896dd246e1413e26b151cbb333ac

data/.gitignore

@@ -0,0 +1,20 @@
+*.gem
+*.rbc
+*.bundle
+*.so
+*.o
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.0

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 ksss
+
+MIT License
+
+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,71 @@
+# Overflow
+
+Overflow is a class to overflow calculated as C language in Ruby.
+
+## Usage
+
+```ruby
+require 'overflow'
+
+def murmur_hash str
+  data = str.dup.unpack("C*")
+  m = 0x5bd1e995
+  r = 16
+  length = Overflow.new "C" # "C" mean 32bit unsigned char (same as pack template)
+  length.set str.bytesize
+  h = length * m
+
+  while 4 <= length
+    d = data.shift(4).pack("C*").unpack("I")[0]
+    h += d # calculate not need `& 0xffffffff`
+    h *= m
+    h ^= h >> r
+    length -= 4
+  end
+
+  if 2 < length
+    h += (data[2] << 16) & 0xffffffff
+  end
+  if 1 < length
+    h += (data[1] << 8) & 0xffffffff
+  end
+  if 0 < length
+    h += data[0]
+    h *= m
+    h ^= h >> r
+  end
+
+  h *= m
+  h ^= h >> 10
+  h *= m
+  h ^= h >> 17
+
+  h
+end
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'overflow'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install overflow
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## License
+
+See the file LICENSE.txt

data/Rakefile

@@ -0,0 +1,21 @@
+require "bundler/gem_tasks"
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = ["-c", "-f progress", "-Ilib"]
+  t.pattern = "spec/**/*_spec.rb"
+  t.verbose = true
+end
+task :spec => :compile
+
+require 'rake/extensiontask'
+spec = Bundler::GemHelper.gemspec
+Rake::ExtensionTask.new('overflow', spec) do |ext|
+  ext.ext_dir = 'ext/overflow'
+  ext.lib_dir = 'lib/overflow'
+end
+
+
+task :default => [:spec]

data/ext/overflow/extconf.rb

@@ -0,0 +1,3 @@
+require 'mkmf'
+
+create_makefile('overflow/overflow')

data/ext/overflow/init.c

@@ -0,0 +1,323 @@
+#include "ruby.h"
+
+typedef enum {
+	i8,
+	ui8,
+	i16,
+	ui16,
+	i32,
+	ui32,
+	i64,
+	ui64
+} types;
+
+typedef uint64_t value_t;
+
+typedef struct {
+	value_t value;
+	types type;
+} overflow_t;
+
+types char2type (char c)
+{
+	switch (c) {
+	case 'c': return i8;
+	case 'C': return ui8;
+	case 's': return i16;
+	case 'S': return ui16;
+	case 'i': return i32;
+	case 'I': return ui32;
+	case 'l': return i32;
+	case 'L': return ui32;
+	case 'q': return i64;
+	case 'Q': return ui64;
+	default:
+		rb_raise(rb_eArgError, "type %c is not support", c);
+	}
+}
+
+static void
+overflow_free(overflow_t* ptr)
+{
+	xfree(ptr);
+}
+
+static VALUE
+overflow_alloc(VALUE self)
+{
+	overflow_t* ptr = ALLOC(overflow_t);
+	return Data_Wrap_Struct(self, 0, overflow_free, ptr);
+}
+
+static VALUE
+overflow_initialize(VALUE self, VALUE obj)
+{
+	overflow_t *ptr;
+	char *p;
+	char c;
+
+	if (rb_type(obj) != T_STRING) {
+		rb_raise(rb_eArgError, "set a type char for `pack' template");
+	}
+
+	Data_Get_Struct(self, overflow_t, ptr);
+	p = RSTRING_PTR(obj);
+
+	ptr->type = char2type(*p);
+	return self;
+}
+
+static VALUE
+overflow_set(VALUE self, VALUE obj)
+{
+	overflow_t *ptr;
+	Data_Get_Struct(self, overflow_t, ptr);
+	VALUE other;
+
+	switch (rb_type(obj)) {
+	case T_FIXNUM:
+		switch (ptr->type) {
+		case i8:   ptr->value = (int8_t)   NUM2LL(obj); break;
+		case ui8:  ptr->value = (uint8_t)  NUM2LL(obj); break;
+		case i16:  ptr->value = (int16_t)  NUM2LL(obj); break;
+		case ui16: ptr->value = (uint16_t) NUM2LL(obj); break;
+		case i32:  ptr->value = (int32_t)  NUM2LL(obj); break;
+		case ui32: ptr->value = (uint32_t) NUM2LL(obj); break;
+		case i64:  ptr->value = (int64_t)  NUM2LL(obj); break;
+		case ui64: ptr->value = (uint64_t) NUM2LL(obj); break;
+		}
+		break;
+	case T_BIGNUM:
+		if (RBIGNUM_POSITIVE_P(obj)) {
+			other = rb_funcall(obj, rb_intern("&"), 1, ULL2NUM(0xffffffffffffffffLL));
+			ptr->value = (uint64_t) NUM2ULL(other);
+		} else {
+			ptr->value = (int64_t) NUM2LL(obj);
+		}
+		break;
+	}
+	return self;
+}
+
+static VALUE
+overflow_to_i(VALUE self)
+{
+	overflow_t *ptr;
+	Data_Get_Struct(self, overflow_t, ptr);
+
+	switch (ptr->type) {
+	case i8:
+		return INT2NUM((int8_t)ptr->value);
+	case ui8:
+		return UINT2NUM((uint8_t)ptr->value);
+	case i16:
+		return INT2NUM((int16_t)ptr->value);
+	case ui16:
+		return UINT2NUM((uint16_t)ptr->value);
+	case i32:
+		return LONG2NUM((int32_t)ptr->value);
+	case ui32:
+		return ULONG2NUM((uint32_t)ptr->value);
+	case i64:
+		return LL2NUM((int64_t)ptr->value);
+	case ui64:
+		return ULL2NUM((uint64_t)ptr->value);
+	}
+}
+
+#define TYPE_PLUS(type, value, other) ((type)((type)(value) + (type)(other)))
+
+static uint64_t
+plus(types type, uint64_t a, uint64_t b)
+{
+	switch (type) {
+	case i8:   return TYPE_PLUS(int8_t, a, b);
+	case ui8:  return TYPE_PLUS(uint8_t, a, b);
+	case i16:  return TYPE_PLUS(int16_t, a, b);
+	case ui16: return TYPE_PLUS(uint16_t, a, b);
+	case i32:  return TYPE_PLUS(int32_t, a, b);
+	case ui32: return TYPE_PLUS(uint32_t, a, b);
+	case i64:  return TYPE_PLUS(int64_t, a, b);
+	case ui64: return TYPE_PLUS(uint64_t, a, b);
+	}
+}
+
+static VALUE
+overflow_plus(VALUE self, VALUE num)
+{
+	overflow_t *ptr;
+	Data_Get_Struct(self, overflow_t, ptr);
+
+	uint64_t a;
+	uint64_t b;
+
+	if (RB_TYPE_P(num, T_BIGNUM)) {
+		num = rb_funcall(num, rb_intern("&"), 1, ULL2NUM(0xffffffffffffffffLL));
+	}
+	a = ptr->value;
+	b = NUM2ULL(num);
+
+	ptr->value = plus(ptr->type, a, b);
+	return self;
+}
+
+#define TYPE_MINUS(type, value, other) ((type)((type)(value) - (type)(other)))
+
+static uint64_t
+minus(types type, uint64_t a, uint64_t b)
+{
+	switch (type) {
+	case i8:   return TYPE_MINUS(int8_t, a, b);
+	case ui8:  return TYPE_MINUS(uint8_t, a, b);
+	case i16:  return TYPE_MINUS(int16_t, a, b);
+	case ui16: return TYPE_MINUS(uint16_t, a, b);
+	case i32:  return TYPE_MINUS(int32_t, a, b);
+	case ui32: return TYPE_MINUS(uint32_t, a, b);
+	case i64:  return TYPE_MINUS(int64_t, a, b);
+	case ui64: return TYPE_MINUS(uint64_t, a, b);
+	}
+}
+
+static VALUE
+overflow_minus(VALUE self, VALUE num)
+{
+	overflow_t *ptr;
+	Data_Get_Struct(self, overflow_t, ptr);
+
+	uint64_t a;
+	uint64_t b;
+
+	if (RB_TYPE_P(num, T_BIGNUM)) {
+		num = rb_funcall(num, rb_intern("&"), 1, ULL2NUM(0xffffffffffffffffLL));
+	}
+	a = ptr->value;
+	b = NUM2ULL(num);
+
+	ptr->value = minus(ptr->type, a, b);
+	return self;
+}
+
+#define TYPE_MUL(type, value, other) ((type)((type)(value) * (type)(other)))
+
+static uint64_t
+mul(types type, uint64_t a, uint64_t b)
+{
+	switch (type) {
+	case i8:   return TYPE_MUL(int8_t, a, b);
+	case ui8:  return TYPE_MUL(uint8_t, a, b);
+	case i16:  return TYPE_MUL(int16_t, a, b);
+	case ui16: return TYPE_MUL(uint16_t, a, b);
+	case i32:  return TYPE_MUL(int32_t, a, b);
+	case ui32: return TYPE_MUL(uint32_t, a, b);
+	case i64:  return TYPE_MUL(int64_t, a, b);
+	case ui64: return TYPE_MUL(uint64_t, a, b);
+	}
+}
+
+static VALUE
+overflow_mul(VALUE self, VALUE num)
+{
+	overflow_t *ptr;
+	Data_Get_Struct(self, overflow_t, ptr);
+
+	uint64_t a;
+	uint64_t b;
+
+	if (RB_TYPE_P(num, T_BIGNUM)) {
+		num = rb_funcall(num, rb_intern("&"), 1, ULL2NUM(0xffffffffffffffffLL));
+	}
+
+	a = ptr->value;
+	b = NUM2ULL(num);
+
+	ptr->value = mul(ptr->type, a, b);
+	return self;
+}
+
+static VALUE
+lshift(overflow_t *ptr, long width)
+{
+	switch (ptr->type) {
+	case i8:   return INT2NUM((int8_t)(ptr->value << width));
+	case ui8:  return UINT2NUM((uint8_t)(ptr->value << width));
+	case i16:  return INT2NUM((int16_t)(ptr->value << width));
+	case ui16: return UINT2NUM((uint16_t)(ptr->value << width));
+	case i32:  return LONG2NUM((int32_t)(ptr->value << width));
+	case ui32: return ULONG2NUM((uint32_t)(ptr->value << width));
+	case i64:  return LONG2NUM((int64_t)(ptr->value << width));
+	case ui64: return ULONG2NUM((uint64_t)(ptr->value << width));
+	}
+}
+
+static VALUE
+rshift(overflow_t *ptr, long width)
+{
+	switch (ptr->type) {
+	case i8:   return INT2NUM((int8_t)(ptr->value >> width));
+	case ui8:  return UINT2NUM((uint8_t)(ptr->value >> width));
+	case i16:  return INT2NUM((int16_t)(ptr->value >> width));
+	case ui16: return UINT2NUM((uint16_t)(ptr->value >> width));
+	case i32:  return LONG2NUM((int32_t)(ptr->value >> width));
+	case ui32: return ULONG2NUM((uint32_t)(ptr->value >> width));
+	case i64:  return LONG2NUM((int64_t)(ptr->value >> width));
+	case ui64: return ULONG2NUM((uint64_t)(ptr->value >> width));
+	}
+}
+
+static VALUE
+overflow_lshift(VALUE self, VALUE obj)
+{
+	long width;
+	overflow_t *ptr;
+	Data_Get_Struct(self, overflow_t, ptr);
+
+	if (!FIXNUM_P(obj))
+		rb_raise(rb_eArgError, "over 64 left shift not support");
+	
+	width = FIX2LONG(obj);
+	if (64 <= width)
+		rb_raise(rb_eArgError, "over 64 left shift not support");
+
+	if (width < 0) {
+		return rshift(ptr, -width);
+	} else {
+		return lshift(ptr, width);
+	}
+}
+
+static VALUE
+overflow_rshift(VALUE self, VALUE obj)
+{
+	long width;
+	overflow_t *ptr;
+	Data_Get_Struct(self, overflow_t, ptr);
+
+	if (!FIXNUM_P(obj))
+		rb_raise(rb_eArgError, "over 64 right shift not support");
+	
+	width = FIX2LONG(obj);
+	if (64 <= width)
+		rb_raise(rb_eArgError, "over 64 right shift not support");
+
+	if (width < 0) {
+		return lshift(ptr, -width);
+	} else {
+		return rshift(ptr, width);
+	}
+}
+
+void
+Init_overflow(void)
+{
+	VALUE cOverflow;
+	cOverflow = rb_define_class("Overflow", rb_cObject);
+	rb_define_alloc_func(cOverflow, overflow_alloc);
+	rb_define_method(cOverflow, "initialize", overflow_initialize, 1);
+	rb_define_method(cOverflow, "set", overflow_set, 1);
+	rb_define_method(cOverflow, "to_i", overflow_to_i, 0);
+	rb_define_method(cOverflow, "+", overflow_plus, 1);
+	rb_define_method(cOverflow, "-", overflow_minus, 1);
+	rb_define_method(cOverflow, "*", overflow_mul, 1);
+	rb_define_method(cOverflow, "<<", overflow_lshift, 1);
+	rb_define_method(cOverflow, ">>", overflow_rshift, 1);
+}

data/lib/overflow.rb

@@ -0,0 +1,6 @@
+begin
+  require "overflow/#{RUBY_VERSION[/\d+.\d+/]}/overflow"
+rescue LoadError
+  require "overflow/overflow"
+end
+require "overflow/version"

data/lib/overflow/version.rb

@@ -0,0 +1,3 @@
+class Overflow
+  VERSION = "0.0.1"
+end

data/overflow.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'overflow/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "overflow"
+  spec.version       = Overflow::VERSION
+  spec.author        = "ksss"
+  spec.email         = "co000ri@gmail.com"
+  spec.description   = %q{Overflow is a class to overflow calculated as C language in Ruby.}
+  spec.summary       = %q{Overflow is a class to overflow calculated as C language in Ruby.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+  spec.extensions    = ["ext/overflow/extconf.rb"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", ['~> 2.11']
+  spec.add_development_dependency "rake-compiler", ["~> 0.8.3"]
+end

data/spec/mem_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Overflow do
+  it "gc safe" do
+    over = Overflow.new "c"
+    GC.start
+    over.set 1
+    GC.start
+    expect(over.to_i).to eq(1)
+  end
+end

data/spec/overflow_spec.rb

@@ -0,0 +1,313 @@
+require 'spec_helper'
+
+describe Overflow do
+  CHAR_MAX   = 0x7f
+  CHAR_MIN   = -0x80
+  UCHAR_MAX  = 0xff
+
+  SHRT_MAX   = 0x7fff
+  SHRT_MIN   = -0x8000
+  USHRT_MAX  = 0xffff
+
+  INT_MAX    = 0x7fffffff
+  INT_MIN    = -0x80000000
+  UINT_MAX   = 0xffffffff
+
+  LLONG_MAX  = 0x7fffffffffffffff
+  LLONG_MIN  = -0x8000000000000000
+  ULLONG_MAX = 0xffffffffffffffff
+
+  it "initialize" do
+    %w{c C s S i I l L q Q}.each do |i|
+      Overflow.new i
+    end
+  end
+
+  it "set and to_i type 'c'" do
+    over = Overflow.new "c"
+    expect(over.set(0).to_i).to eq(0)
+    expect(over.set(CHAR_MAX).to_i).to eq(CHAR_MAX)
+    expect(over.set(CHAR_MAX + 1).to_i).to eq(CHAR_MIN)
+    expect(over.set(UCHAR_MAX).to_i).to eq(-1)
+    expect(over.set(UCHAR_MAX + 1).to_i).to eq(0)
+    expect(over.set(UCHAR_MAX + 2).to_i).to eq(1)
+  end
+
+  it "set and to_i type 'i'" do
+    over = Overflow.new "i"
+    expect(over.set(INT_MAX).to_i).to eq(INT_MAX)
+    expect(over.set(INT_MAX + 1).to_i).to eq(INT_MIN)
+    expect(over.set(UINT_MAX).to_i).to eq(-1)
+    expect(over.set(UINT_MAX + 1).to_i).to eq(0)
+    expect(over.set(UINT_MAX + 2).to_i).to eq(1)
+  end
+
+  it "set and to_i type 'q'" do
+    over = Overflow.new "q"
+    expect(over.set(LLONG_MAX).to_i).to eq(LLONG_MAX)
+    expect(over.set(LLONG_MAX + 1).to_i).to eq(LLONG_MIN)
+    expect(over.set(ULLONG_MAX).to_i).to eq(-1)
+    expect(over.set(ULLONG_MAX + 1).to_i).to eq(0)
+    expect(over.set(ULLONG_MAX + 2).to_i).to eq(1)
+  end
+
+  it "<< 8bit" do
+    over = Overflow.new "c"
+    over.set(CHAR_MAX)
+    over = over << 7
+    expect(over.to_i).to eq(CHAR_MIN)
+
+    over = Overflow.new "C"
+    over.set(UCHAR_MAX)
+    over = over << 7
+    expect(over.to_i).to eq(CHAR_MAX + 1)
+  end
+
+  it "<< 16bit" do
+    over = Overflow.new "s"
+    over.set(SHRT_MAX)
+    over = over << 15
+    expect(over.to_i).to eq(SHRT_MIN)
+
+    over = Overflow.new "S"
+    over.set(USHRT_MAX)
+    over = over << 15
+    expect(over.to_i).to eq(SHRT_MAX + 1)
+  end
+
+  it "<< 32bit" do
+    over = Overflow.new "i"
+    over.set(INT_MAX)
+    over = over << 31
+    expect(over.to_i).to eq(INT_MIN)
+
+    over = Overflow.new "I"
+    over.set(UINT_MAX)
+    over = over << 31
+    expect(over.to_i).to eq(INT_MAX + 1)
+  end
+
+  it "<< 64bit" do
+    over = Overflow.new "q"
+    over.set(LLONG_MAX)
+    over = over << 63
+    expect(over.to_i).to eq(LLONG_MIN)
+
+    over = Overflow.new "Q"
+    over.set(ULLONG_MAX)
+    over = over << 63
+    expect(over.to_i).to eq(LLONG_MAX + 1)
+  end
+
+  it ">> 8bit" do
+    over = Overflow.new "c"
+    over.set(CHAR_MAX)
+    over = over >> 7
+    expect(over.to_i).to eq(0)
+
+    over = Overflow.new "C"
+    over.set(UCHAR_MAX)
+    over = over >> 7
+    expect(over.to_i).to eq(1)
+  end
+
+  it ">> 16bit" do
+    over = Overflow.new "s"
+    over.set(SHRT_MAX)
+    over = over >> 15
+    expect(over.to_i).to eq(0)
+
+    over = Overflow.new "S"
+    over.set(USHRT_MAX)
+    over = over >> 15
+    expect(over.to_i).to eq(1)
+  end
+
+  it ">> 32bit" do
+    over = Overflow.new "i"
+    over.set(INT_MAX)
+    over = over >> 31
+    expect(over.to_i).to eq(0)
+
+    over = Overflow.new "I"
+    over.set(UINT_MAX)
+    over = over >> 31
+    expect(over.to_i).to eq(1)
+  end
+
+  it ">> 64bit" do
+    over = Overflow.new "q"
+    over.set(LLONG_MAX)
+    over = over >> 63
+    expect(over.to_i).to eq(0)
+
+    over = Overflow.new "Q"
+    over.set(ULLONG_MAX)
+    over = over >> 63
+    expect(over.to_i).to eq(1)
+  end
+
+  it "+ 8bit" do
+    over = Overflow.new "c"
+    over.set(CHAR_MAX)
+    over += 1
+    expect(over.to_i).to eq(CHAR_MIN)
+
+    over = Overflow.new "C"
+    over.set(UCHAR_MAX)
+    over += 1
+    expect(over.to_i).to eq(0)
+  end
+
+  it "+ 16bit" do
+    over = Overflow.new "s"
+    over.set(SHRT_MAX)
+    over += 1
+    expect(over.to_i).to eq(SHRT_MIN)
+
+    over = Overflow.new "S"
+    over.set(USHRT_MAX)
+    over += 1
+    expect(over.to_i).to eq(0)
+  end
+
+  it "+ 32bit" do
+    over = Overflow.new "l"
+    over.set(INT_MAX)
+    over += 1
+    expect(over.to_i).to eq(INT_MIN)
+
+    over = Overflow.new "L"
+    over.set(UINT_MAX)
+    over += 1
+    expect(over.to_i).to eq(0)
+  end
+
+  it "+ 64bit" do
+    over = Overflow.new "q"
+    over.set(LLONG_MAX)
+    over += 1
+    expect(over.to_i).to eq(LLONG_MIN)
+
+    over = Overflow.new "Q"
+    over.set(ULLONG_MAX)
+    over += 1
+    expect(over.to_i).to eq(0)
+  end
+
+  it "- 8bit" do
+    over = Overflow.new "c"
+    over.set(CHAR_MIN)
+    over -= 1
+    expect(over.to_i).to eq(CHAR_MAX)
+
+    over = Overflow.new "C"
+    over.set(0)
+    over -= 1
+    expect(over.to_i).to eq(UCHAR_MAX)
+  end
+
+  it "- 16bit" do
+    over = Overflow.new "s"
+    over.set(SHRT_MIN)
+    over -= 1
+    expect(over.to_i).to eq(SHRT_MAX)
+
+    over = Overflow.new "S"
+    over.set(0)
+    over -= 1
+    expect(over.to_i).to eq(USHRT_MAX)
+  end
+
+  it "- 32bit" do
+    over = Overflow.new "l"
+    over.set(INT_MIN)
+    over -= 1
+    expect(over.to_i).to eq(INT_MAX)
+
+    over = Overflow.new "L"
+    over.set(0)
+    over -= 1
+    expect(over.to_i).to eq(UINT_MAX)
+  end
+
+  it "- 64bit" do
+    over = Overflow.new "q"
+    over.set(LLONG_MIN)
+    over -= 1
+    expect(over.to_i).to eq(LLONG_MAX)
+
+    over = Overflow.new "Q"
+    over.set(0)
+    over -= 1
+    expect(over.to_i).to eq(ULLONG_MAX)
+  end
+
+  it "* 8bit" do
+    over = Overflow.new "c"
+    over.set(CHAR_MAX)
+    over *= CHAR_MAX
+    expect(over.to_i).to eq(1)
+
+    over.set(CHAR_MIN)
+    over *= CHAR_MIN
+    expect(over.to_i).to eq(0)
+
+    over = Overflow.new "C"
+    over.set(UCHAR_MAX)
+    over *= UCHAR_MAX
+    expect(over.to_i).to eq(1)
+  end
+
+  it "* 16bit" do
+    over = Overflow.new "s"
+    over.set(SHRT_MAX)
+    over *= SHRT_MAX
+    expect(over.to_i).to eq(1)
+
+    over.set(SHRT_MIN)
+    over *= SHRT_MIN
+    expect(over.to_i).to eq(0)
+
+    over = Overflow.new "S"
+    over.set(USHRT_MAX)
+    over *= USHRT_MAX
+    expect(over.to_i).to eq(1)
+  end
+
+  it "* 32bit" do
+    over = Overflow.new "l"
+    over.set(INT_MAX)
+    over *= INT_MAX
+    expect(over.to_i).to eq(1)
+
+    over.set(INT_MIN)
+    over *= INT_MIN
+    expect(over.to_i).to eq(0)
+
+    over = Overflow.new "L"
+    over.set(UINT_MAX)
+    over *= UINT_MAX
+    expect(over.to_i).to eq(1)
+  end
+
+  it "* 64bit" do
+    over = Overflow.new "q"
+    over.set(LLONG_MAX)
+    over *= LLONG_MAX
+    expect(over.to_i).to eq(1)
+
+    over.set(LLONG_MIN)
+    over *= LLONG_MIN
+    expect(over.to_i).to eq(0)
+
+    over = Overflow.new "Q"
+    over.set(ULLONG_MAX)
+    over *= ULLONG_MAX
+    expect(over.to_i).to eq(1)
+  end
+
+end
+
+
+

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require 'overflow'

metadata

@@ -0,0 +1,118 @@
+--- !ruby/object:Gem::Specification
+name: overflow
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- ksss
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-12-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !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'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.11'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.3
+description: Overflow is a class to overflow calculated as C language in Ruby.
+email: co000ri@gmail.com
+executables: []
+extensions:
+- ext/overflow/extconf.rb
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- ext/overflow/extconf.rb
+- ext/overflow/init.c
+- lib/overflow.rb
+- lib/overflow/version.rb
+- overflow.gemspec
+- spec/mem_spec.rb
+- spec/overflow_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.0
+signing_key: 
+specification_version: 4
+summary: Overflow is a class to overflow calculated as C language in Ruby.
+test_files:
+- spec/mem_spec.rb
+- spec/overflow_spec.rb
+- spec/spec_helper.rb
+has_rdoc: