 JSONEncoderTests.test("testDecoderStateThrowOnDecode") { TestJSONEncoder().testDecoderStateThrowOnDecode() }
 JSONEncoderTests.test("testDecoderStateThrowOnDecodeCustomDate") { TestJSONEncoder().testDecoderStateThrowOnDecodeCustomDate() }
 JSONEncoderTests.test("testDecoderStateThrowOnDecodeCustomData") { TestJSONEncoder().testDecoderStateThrowOnDecodeCustomData() }
+JSONEncoderTests.test("testEncodingDictionaryFailureKeyPath") { TestJSONEncoder().testEncodingDictionaryFailureKeyPath() }
+JSONEncoderTests.test("testEncodingDictionaryFailureKeyPathNested") { TestJSONEncoder().testEncodingDictionaryFailureKeyPathNested() }
+JSONEncoderTests.test("testDecodingDictionaryFailureKeyPath") { TestJSONEncoder().testDecodingDictionaryFailureKeyPath() }
+JSONEncoderTests.test("testDecodingDictionaryFailureKeyPathNested") { TestJSONEncoder().testDecodingDictionaryFailureKeyPathNested() }
 runAllTests()
 #endif

    let result = try! decoder.decode([String: String].self, from: input)

    expectEqual(["leave_me_alone": "test"], result)
  }
  
  private struct DecodeMe3 : Codable {


    expectEqual(expected, resultString)
  }

  private struct EncodeFailure : Encodable {
    var someValue: Double
  }

  private struct EncodeFailureNested : Encodable {
    var nestedValue: EncodeFailure
  }

  func testEncodingDictionaryFailureKeyPath() {
    let toEncode: [String: EncodeFailure] = ["key": EncodeFailure(someValue: Double.nan)]

    let encoder = JSONEncoder()
    encoder.keyEncodingStrategy = .convertToSnakeCase
    do {
      _ = try encoder.encode(toEncode)
    } catch EncodingError.invalidValue(let (_, context)) {
      expectEqual(2, context.codingPath.count)
      expectEqual("key", context.codingPath[0].stringValue)
      expectEqual("someValue", context.codingPath[1].stringValue)
    } catch {
      expectUnreachable("Unexpected error: \(String(describing: error))")
    }
  }

  func testEncodingDictionaryFailureKeyPathNested() {
    let toEncode: [String: [String: EncodeFailureNested]] = ["key": ["sub_key": EncodeFailureNested(nestedValue: EncodeFailure(someValue: Double.nan))]]

    let encoder = JSONEncoder()
    encoder.keyEncodingStrategy = .convertToSnakeCase
    do {
      _ = try encoder.encode(toEncode)
    } catch EncodingError.invalidValue(let (_, context)) {
      expectEqual(4, context.codingPath.count)
      expectEqual("key", context.codingPath[0].stringValue)
      expectEqual("sub_key", context.codingPath[1].stringValue)
      expectEqual("nestedValue", context.codingPath[2].stringValue)
      expectEqual("someValue", context.codingPath[3].stringValue)
    } catch {
      expectUnreachable("Unexpected error: \(String(describing: error))")
    }
  }

  private struct EncodeNested : Encodable {
    let nestedValue: EncodeMe
  }
