diff --git a/src/main/java/org/junit/Assert.java b/src/main/java/org/junit/Assert.java
index a3d7905e6d24..5c7378c02873 100644
--- a/src/main/java/org/junit/Assert.java
+++ b/src/main/java/org/junit/Assert.java
@@ -772,6 +772,54 @@ public static void assertSame(String message, Object expected, Object actual) {
         failNotSame(message, expected, actual);
     }
 
+    /**
+     * Asserts that two boolean values are the same. If they are not, an
+     * {@link AssertionError} is thrown with the given message.
+     *
+     * @param message the identifying message for the {@link AssertionError} (<code>null</code>
+     * okay)
+     * @param expected the expected object
+     * @param actual the value to compare to <code>expected</code>
+     */
+    public static void assertSame(String message, boolean expected, boolean actual) {
+        if (expected == actual) {
+            return;
+        }
+        failNotSame(message, expected, actual);
+    }
+
+    /**
+     * Asserts that two long values are the same. If they are not, an
+     * {@link AssertionError} is thrown with the given message.
+     *
+     * @param message the identifying message for the {@link AssertionError} (<code>null</code>
+     * okay)
+     * @param expected the expected object
+     * @param actual the value to compare to <code>expected</code>
+     */
+    public static void assertSame(String message, long expected, long actual) {
+        if (expected == actual) {
+            return;
+        }
+        failNotSame(message, expected, actual);
+    }
+
+    /**
+     * Asserts that two double values are the same. If they are not, an
+     * {@link AssertionError} is thrown with the given message.
+     *
+     * @param message the identifying message for the {@link AssertionError} (<code>null</code>
+     * okay)
+     * @param expected the expected object
+     * @param actual the value to compare to <code>expected</code>
+     */
+    public static void assertSame(String message, double expected, double actual) {
+        if (expected == actual) {
+            return;
+        }
+        failNotSame(message, expected, actual);
+    }
+
     /**
      * Asserts that two objects refer to the same object. If they are not the
      * same, an {@link AssertionError} without a message is thrown.
@@ -783,6 +831,87 @@ public static void assertSame(Object expected, Object actual) {
         assertSame(null, expected, actual);
     }
 
+    /**
+     * Asserts that two boolean values are the same. If they are not the
+     * same, an {@link AssertionError} without a message is thrown.
+     *
+     * @param expected the expected value
+     * @param actual the value to compare to <code>expected</code>
+     */
+    public static void assertSame(boolean expected, boolean actual) {
+        assertSame(null, expected, actual);
+    }
+
+    /**
+     * Asserts that two long values are the same. If they are not the
+     * same, an {@link AssertionError} without a message is thrown.
+     *
+     * @param expected the expected value
+     * @param actual the value to compare to <code>expected</code>
+     */
+    public static void assertSame(long expected, long actual) {
+        assertSame(null, expected, actual);
+    }
+
+    /**
+     * Asserts that two double values are the same. If they are not the
+     * same, an {@link AssertionError} without a message is thrown.
+     *
+     * @param expected the expected value
+     * @param actual the value to compare to <code>expected</code>
+     */
+    public static void assertSame(double expected, double actual) {
+        assertSame(null, expected, actual);
+    }
+
+    /**
+     * Asserts that two boolean values are not the same. If they are the same value,
+     * an {@link AssertionError} is thrown with the given message.
+     *
+     * @param message the identifying message for the {@link AssertionError} (<code>null</code>
+     * okay)
+     * @param unexpected the value you don't expect
+     * @param actual the value to compare to <code>unexpected</code>
+     */
+    public static void assertNotSame(String message, boolean unexpected,
+            boolean actual) {
+        if (unexpected == actual) {
+            failSame(message);
+        }
+    }
+
+    /**
+     * Asserts that two long values are not the same. If they are the same value,
+     * an {@link AssertionError} is thrown with the given message.
+     *
+     * @param message the identifying message for the {@link AssertionError} (<code>null</code>
+     * okay)
+     * @param unexpected the value you don't expect
+     * @param actual the value to compare to <code>unexpected</code>
+     */
+    public static void assertNotSame(String message, long unexpected,
+            long actual) {
+        if (unexpected == actual) {
+            failSame(message);
+        }
+    }
+
+    /**
+     * Asserts that two double values are not the same. If they are the same value,
+     * an {@link AssertionError} is thrown with the given message.
+     *
+     * @param message the identifying message for the {@link AssertionError} (<code>null</code>
+     * okay)
+     * @param unexpected the value you don't expect
+     * @param actual the value to compare to <code>unexpected</code>
+     */
+    public static void assertNotSame(String message, double unexpected,
+            double actual) {
+        if (unexpected == actual) {
+            failSame(message);
+        }
+    }
+
     /**
      * Asserts that two objects do not refer to the same object. If they do
      * refer to the same object, an {@link AssertionError} is thrown with the
@@ -800,6 +929,42 @@ public static void assertNotSame(String message, Object unexpected,
         }
     }
 
+    /**
+     * Asserts that two boolean values are not the same value. If they are
+     * the same, an {@link AssertionError} without a message is
+     * thrown.
+     *
+     * @param unexpected the value you don't expect
+     * @param actual the value to compare to <code>unexpected</code>
+     */
+    public static void assertNotSame(boolean unexpected, boolean actual) {
+        assertNotSame(null, unexpected, actual);
+    }
+
+    /**
+     * Asserts that two long values are not the same value. If they are
+     * the same, an {@link AssertionError} without a message is
+     * thrown.
+     *
+     * @param unexpected the value you don't expect
+     * @param actual the value to compare to <code>unexpected</code>
+     */
+    public static void assertNotSame(long unexpected, long actual) {
+        assertNotSame(null, unexpected, actual);
+    }
+
+    /**
+     * Asserts that two double values are not the same value. If they are
+     * the same, an {@link AssertionError} without a message is
+     * thrown.
+     *
+     * @param unexpected the value you don't expect
+     * @param actual the value to compare to <code>unexpected</code>
+     */
+    public static void assertNotSame(double unexpected, double actual) {
+        assertNotSame(null, unexpected, actual);
+    }
+
     /**
      * Asserts that two objects do not refer to the same object. If they do
      * refer to the same object, an {@link AssertionError} without a message is
diff --git a/src/test/java/org/junit/tests/assertion/AssertionTest.java b/src/test/java/org/junit/tests/assertion/AssertionTest.java
index d0c3bdfddc59..443ca95ce7dc 100644
--- a/src/test/java/org/junit/tests/assertion/AssertionTest.java
+++ b/src/test/java/org/junit/tests/assertion/AssertionTest.java
@@ -605,10 +605,271 @@ public void notSameWithMessage() {
     }
 
     @Test
-    public void notSameNullMessage() {
-        Object o = new Object();
+    public void sameBoolean() {
+        boolean b = true;
+        assertSame(b, b);
+    }
+
+    @Test
+    public void sameByte() {
+        byte b = 123;
+        assertSame(b, b);
+    }
+
+    @Test
+    public void sameChar() {
+        char c = '\u0123';
+        assertSame(c, c);
+    }
+
+    @Test
+    public void sameShort() {
+        short n = 1234;
+        assertSame(n, n);
+    }
+
+    @Test
+    public void sameIntSmall() {
+        int i = 123;
+        assertSame(i, i);
+    }
+
+    @Test
+    public void sameIntLarge() {
+        int i = 123456;
+        assertSame(i, i);
+    }
+
+    @Test
+    public void sameIntFloat() {
+        int i = 123456;
+        float f = 123456;
+        assertSame(i, f);
+    }
+
+    @Test
+    public void sameFloatInt() {
+        int i = 123456;
+        float f = 123456;
+        assertSame(i, f);
+    }
+
+    public void sameIntLong() {
+        int i = 123456;
+        long l = 123456;
+        assertSame(i, l);
+    }
+
+    @Test
+    public void sameLongInt() {
+        long l = 123456;
+        int i = 123456;
+        assertSame(l, i);
+    }
+
+    @Test
+    public void sameFloat() {
+        float f = 123.456f;
+        assertSame(f, f);
+    }
+
+    @Test
+    public void sameDouble() {
+        double d = 123.456E129;
+        assertSame(d, d);
+    }
+
+    @Test
+    public void notSameBoolean() {
+        boolean b1 = true;
+        boolean b2 = false;
+        assertNotSame(b1, b2);
+    }
+
+    @Test
+    public void notSameByte() {
+        byte b1 = 123;
+        byte b2 = 124;
+        assertNotSame(b1, b2);
+    }
+
+    @Test
+    public void notSameChar() {
+        char c1 = '\u0123';
+        char c2 = '\u0124';
+        assertNotSame(c1, c2);
+    }
+
+    @Test
+    public void notSameShort() {
+        short a = 1234;
+        short b = 1235;
+        assertNotSame(a, b);
+    }
+
+    @Test
+    public void notSameIntSmall() {
+        int i1 = 111;
+        int i2 = 112;
+        assertNotSame(i1, i2);
+    }
+
+    @Test
+    public void notSameIntLarge() {
+        int i1 = 1111111111;
+        int i2 = 1111111112;
+        assertNotSame(i1, i2);
+    }
+
+    @Test
+    public void notSameLong() {
+        long l1 = 11111111111L;
+        long l2 = 11111111112L;
+        assertNotSame(l1, l2);
+    }
+
+    @Test
+    public void notSameFloat() {
+        float f1 = 1111111.1f;
+        float f2 = 1111111.2f;
+        assertNotSame(f1, f2);
+    }
+
+    @Test
+    public void notSameDouble() {
+        double d1 = 1.111E129;
+        double d2 = 1.112E129;
+        assertNotSame(d1, d2);
+    }
+
+    @Test(expected = AssertionError.class)
+    public void sameBooleanFail() {
+        assertSame(true, false);
+    }
+
+    @Test(expected = AssertionError.class)
+    public void sameByteFail() {
+        assertSame((byte)111, (byte)112);
+    }
+
+    @Test(expected = AssertionError.class)
+    public void sameShortFail() {
+        assertSame((short)1234, (short)1235);
+    }
+
+    @Test(expected = AssertionError.class)
+    public void sameIntSmallFail() {
+        assertSame(111, 112);
+    }
+
+    @Test(expected = AssertionError.class)
+    public void sameIntLargeFail() {
+        assertSame(111111, 111112);
+    }
+
+    @Test(expected = AssertionError.class)
+    public void sameLongFail() {
+        assertSame(11111111111L, 11111111112L);
+    }
+
+    @Test(expected = AssertionError.class)
+    public void sameFloatFail() {
+        assertSame(1111111.1f, 1111111.2f);
+    }
+
+    @Test(expected = AssertionError.class)
+    public void sameDoubleFail() {
+        assertSame(1.111E129, 1.112E129);
+    }
+
+    @Test(expected = AssertionError.class)
+    public void notSameBooleanFail() {
+        boolean b = true;
+        assertNotSame(b, b);
+    }
+
+    @Test(expected = AssertionError.class)
+    public void notSameByteFail() {
+        byte b = 123;
+        assertNotSame(b, b);
+    }
+
+    @Test(expected = AssertionError.class)
+    public void notSameShortFail() {
+        short a = 1234;
+        assertNotSame(a, a);
+    }
+
+    @Test(expected = AssertionError.class)
+    public void notSameIntSmallFail() {
+        int i = 123;
+        assertNotSame(i, i);
+    }
+    
+    @Test(expected = AssertionError.class)
+    public void notSameIntLargeFail() {
+        int i = 111111;
+        assertNotSame(i, i);
+    }
+
+    @Test(expected = AssertionError.class)
+    public void notSameLongFail() {
+        long l = 11111111111L;
+        assertNotSame(l, l);
+    }
+
+    @Test(expected = AssertionError.class)
+    public void notSameFloatFail() {
+        float f = 1111111.1f;
+        assertNotSame(f, f);
+    }
+
+    @Test(expected = AssertionError.class)
+    public void notSameDoubleFail() {
+        double d =  1.111E129;
+        assertNotSame(d, d);
+    }
+
+    @Test
+    public void sameIntWithMessage() {
+        try {
+            assertSame("not same", 111111, 111112);
+        } catch (AssertionError exception) {
+            assertEquals("not same expected same:<111111> was not:<111112>",
+                    exception.getMessage());
+            return;
+        }
+        throw new AssertionError(ASSERTION_ERROR_EXPECTED);
+    }
+
+    @Test
+    public void sameIntNullMessage() {
+        try {
+            assertSame(111111, 111112);
+        } catch (AssertionError exception) {
+            assertEquals("expected same:<111111> was not:<111112>", exception.getMessage());
+            return;
+        }
+        throw new AssertionError(ASSERTION_ERROR_EXPECTED);
+    }
+
+    @Test
+    public void notSameIntWithMessage() {
+        int i = 111111;
+        try {
+            assertNotSame("message", i, i);
+        } catch (AssertionError exception) {
+            assertEquals("message expected not same", exception.getMessage());
+            return;
+        }
+        throw new AssertionError(ASSERTION_ERROR_EXPECTED);
+    }
+
+    @Test
+    public void notSameIntNullMessage() {
+        int i = 111111;
         try {
-            assertNotSame(o, o);
+            assertNotSame(i, i);
         } catch (AssertionError exception) {
             assertEquals("expected not same", exception.getMessage());
             return;