[swift-3.0-preview-1-branch][stdlib] Fix the definition of nextUp and nextDown for floating point (#2865)

* [stdlib] Add tests for FloatingPoint's nextUp and nextDown

* [stdlib] Fix for nextUp and nextDown

Author: gribozavr

stdlib/private/StdlibUnittest/StdlibUnittest.swift.gyb

@@ -238,25 +238,25 @@ public func expectOptionalEqual${Generic}(
 
 %end
 
-public func expectLT(_ lhs: Int, _ rhs: Int, ${TRACE}) {
+public func expectLT<T : Comparable>(_ lhs: T, _ rhs: T, ${TRACE}) {
   if !(lhs < rhs) {
     expectationFailure("\(lhs) < \(rhs)", trace: ${trace})
   }
 }
 
-public func expectLE(_ lhs: Int, _ rhs: Int, ${TRACE}) {
+public func expectLE<T : Comparable>(_ lhs: T, _ rhs: T, ${TRACE}) {
   if !(lhs <= rhs) {
     expectationFailure("\(lhs) <= \(rhs)", trace: ${trace})
   }
 }
 
-public func expectGT(_ lhs: Int, _ rhs: Int, ${TRACE}) {
+public func expectGT<T : Comparable>(_ lhs: T, _ rhs: T, ${TRACE}) {
   if !(lhs > rhs) {
     expectationFailure("\(lhs) > \(rhs)", trace: ${trace})
   }
 }
 
-public func expectGE(_ lhs: Int, _ rhs: Int, ${TRACE}) {
+public func expectGE<T : Comparable>(_ lhs: T, _ rhs: T, ${TRACE}) {
   if !(lhs >= rhs) {
     expectationFailure("\(lhs) >= \(rhs)", trace: ${trace})
   }

stdlib/public/core/FloatingPointTypes.swift.gyb

@@ -480,6 +480,9 @@ extension ${Self}: BinaryFloatingPoint {
           exponentBitPattern: exponentBitPattern - 1,
           significandBitPattern: ${Self}._significandMask)
       }
+      return ${Self}(sign: .minus,
+        exponentBitPattern: exponentBitPattern,
+        significandBitPattern: significandBitPattern - 1)
     }
     if isInfinite { return self }
     if significandBitPattern == ${Self}._significandMask {

test/1_stdlib/FloatingPoint.swift.gyb

@@ -171,6 +171,42 @@ FloatingPoint.test("Double/HashValueZero") {
   expectEqual(zero.hashValue, negativeZero.hashValue)
 }
 
+let floatNextUpDownTests: [(Float, Float)] = [
+  (.nan, .nan),
+  (.greatestFiniteMagnitude, .infinity),
+  (-.infinity, -.greatestFiniteMagnitude),
+  (0x1.fffffep-1, 1.0), (1.0, 0x1.000002p+0),
+  (-0x1p-149, -0.0), (0.0, 0x1p-149),
+  (0x1.effffep-1, 0.96875), (0.96875, 0x1.f00002p-1),
+]
+
+FloatingPoint.test("Float.nextUp, .nextDown")
+  .forEach(in: floatNextUpDownTests) {
+  (prev, succ) in
+  expectEqual(succ.bitPattern, prev.nextUp.bitPattern)
+  expectEqual(prev.bitPattern, succ.nextDown.bitPattern)
+  expectEqual((-succ).bitPattern, (-prev).nextDown.bitPattern)
+  expectEqual((-prev).bitPattern, (-succ).nextUp.bitPattern)  
+}
+
+let doubleNextUpDownTests: [(Double, Double)] = [
+  (.nan, .nan),
+  (.greatestFiniteMagnitude, .infinity),
+  (-.infinity, -.greatestFiniteMagnitude),
+  (0x1.fffffffffffffp-1, 1.0), (1.0, 0x1.0000000000001p+0),
+  (-0x1p-1074, -0.0), (0.0, 0x1p-1074),
+  (0x1.effffffffffffp-1, 0.96875), (0.96875, 0x1.f000000000001p-1),
+]
+
+FloatingPoint.test("Double.nextUp, .nextDown")
+  .forEach(in: doubleNextUpDownTests) {
+  (prev, succ) in
+  expectEqual(succ.bitPattern, prev.nextUp.bitPattern)
+  expectEqual(prev.bitPattern, succ.nextDown.bitPattern)
+  expectEqual((-succ).bitPattern, (-prev).nextDown.bitPattern)
+  expectEqual((-prev).bitPattern, (-succ).nextUp.bitPattern)  
+}
+
 #if arch(i386) || arch(x86_64)
 
 FloatingPoint.test("Float80/IntegerLiteralConvertible") {