
(ns clojure.test-clojure.generated-functional-adapters-in-def-requiring-reflection
  (:use clojure.test)
  (:require [clojure.string :as str])
  (:import (clojure.test AdapterExerciser)))

  (deftest functional-adapters-in-def
           (def exerciser (AdapterExerciser.))
           (def Ladapter (fn [] (long 1)))
           (is (= (.methodL exerciser Ladapter) "L"))
           (def Iadapter (fn [] 1))
           (is (= (.methodI exerciser Iadapter) "I"))
           (def Sadapter (fn [] (short 1)))
           (is (= (.methodS exerciser Sadapter) "S"))
           (def Badapter (fn [] (byte 1)))
           (is (= (.methodB exerciser Badapter) "B"))
           (def Dadapter (fn [] (double 1)))
           (is (= (.methodD exerciser Dadapter) "D"))
           (def Fadapter (fn [] (float 1)))
           (is (= (.methodF exerciser Fadapter) "F"))
           (def Oadapter (fn [] exerciser))
           (is (= (.methodO exerciser Oadapter) "O"))
           (def LLadapter (fn [^long a] (long 1)))
           (is (= (.methodLL exerciser LLadapter) "LL"))
           (def DLadapter (fn [^double a] (long 1)))
           (is (= (.methodDL exerciser DLadapter) "DL"))
           (def OLadapter (fn [^AdapterExerciser a] (long 1)))
           (is (= (.methodOL exerciser OLadapter) "OL"))
           (def LIadapter (fn [^long a] 1))
           (is (= (.methodLI exerciser LIadapter) "LI"))
           (def DIadapter (fn [^double a] 1))
           (is (= (.methodDI exerciser DIadapter) "DI"))
           (def OIadapter (fn [^AdapterExerciser a] 1))
           (is (= (.methodOI exerciser OIadapter) "OI"))
           (def LSadapter (fn [^long a] (short 1)))
           (is (= (.methodLS exerciser LSadapter) "LS"))
           (def DSadapter (fn [^double a] (short 1)))
           (is (= (.methodDS exerciser DSadapter) "DS"))
           (def OSadapter (fn [^AdapterExerciser a] (short 1)))
           (is (= (.methodOS exerciser OSadapter) "OS"))
           (def LBadapter (fn [^long a] (byte 1)))
           (is (= (.methodLB exerciser LBadapter) "LB"))
           (def DBadapter (fn [^double a] (byte 1)))
           (is (= (.methodDB exerciser DBadapter) "DB"))
           (def OBadapter (fn [^AdapterExerciser a] (byte 1)))
           (is (= (.methodOB exerciser OBadapter) "OB"))
           (def LDadapter (fn [^long a] (double 1)))
           (is (= (.methodLD exerciser LDadapter) "LD"))
           (def DDadapter (fn [^double a] (double 1)))
           (is (= (.methodDD exerciser DDadapter) "DD"))
           (def ODadapter (fn [^AdapterExerciser a] (double 1)))
           (is (= (.methodOD exerciser ODadapter) "OD"))
           (def LFadapter (fn [^long a] (float 1)))
           (is (= (.methodLF exerciser LFadapter) "LF"))
           (def DFadapter (fn [^double a] (float 1)))
           (is (= (.methodDF exerciser DFadapter) "DF"))
           (def OFadapter (fn [^AdapterExerciser a] (float 1)))
           (is (= (.methodOF exerciser OFadapter) "OF"))
           (def LOadapter (fn [^long a] exerciser))
           (is (= (.methodLO exerciser LOadapter) "LO"))
           (def DOadapter (fn [^double a] exerciser))
           (is (= (.methodDO exerciser DOadapter) "DO"))
           (def OOadapter (fn [^AdapterExerciser a] exerciser))
           (is (= (.methodOO exerciser OOadapter) "OO"))
           (def LLLadapter (fn [^long a ^long b] (long 1)))
           (is (= (.methodLLL exerciser LLLadapter) "LLL"))
           (def LOLadapter (fn [^long a ^AdapterExerciser b] (long 1)))
           (is (= (.methodLOL exerciser LOLadapter) "LOL"))
           (def OLLadapter (fn [^AdapterExerciser a ^long b] (long 1)))
           (is (= (.methodOLL exerciser OLLadapter) "OLL"))
           (def DDLadapter (fn [^double a ^double b] (long 1)))
           (is (= (.methodDDL exerciser DDLadapter) "DDL"))
           (def LDLadapter (fn [^long a ^double b] (long 1)))
           (is (= (.methodLDL exerciser LDLadapter) "LDL"))
           (def DLLadapter (fn [^double a ^long b] (long 1)))
           (is (= (.methodDLL exerciser DLLadapter) "DLL"))
           (def OOLadapter (fn [^AdapterExerciser a ^AdapterExerciser b] (long 1)))
           (is (= (.methodOOL exerciser OOLadapter) "OOL"))
           (def ODLadapter (fn [^AdapterExerciser a ^double b] (long 1)))
           (is (= (.methodODL exerciser ODLadapter) "ODL"))
           (def DOLadapter (fn [^double a ^AdapterExerciser b] (long 1)))
           (is (= (.methodDOL exerciser DOLadapter) "DOL"))
           (def LLIadapter (fn [^long a ^long b] 1))
           (is (= (.methodLLI exerciser LLIadapter) "LLI"))
           (def LOIadapter (fn [^long a ^AdapterExerciser b] 1))
           (is (= (.methodLOI exerciser LOIadapter) "LOI"))
           (def OLIadapter (fn [^AdapterExerciser a ^long b] 1))
           (is (= (.methodOLI exerciser OLIadapter) "OLI"))
           (def DDIadapter (fn [^double a ^double b] 1))
           (is (= (.methodDDI exerciser DDIadapter) "DDI"))
           (def LDIadapter (fn [^long a ^double b] 1))
           (is (= (.methodLDI exerciser LDIadapter) "LDI"))
           (def DLIadapter (fn [^double a ^long b] 1))
           (is (= (.methodDLI exerciser DLIadapter) "DLI"))
           (def OOIadapter (fn [^AdapterExerciser a ^AdapterExerciser b] 1))
           (is (= (.methodOOI exerciser OOIadapter) "OOI"))
           (def ODIadapter (fn [^AdapterExerciser a ^double b] 1))
           (is (= (.methodODI exerciser ODIadapter) "ODI"))
           (def DOIadapter (fn [^double a ^AdapterExerciser b] 1))
           (is (= (.methodDOI exerciser DOIadapter) "DOI"))
           (def LLSadapter (fn [^long a ^long b] (short 1)))
           (is (= (.methodLLS exerciser LLSadapter) "LLS"))
           (def LOSadapter (fn [^long a ^AdapterExerciser b] (short 1)))
           (is (= (.methodLOS exerciser LOSadapter) "LOS"))
           (def OLSadapter (fn [^AdapterExerciser a ^long b] (short 1)))
           (is (= (.methodOLS exerciser OLSadapter) "OLS"))
           (def DDSadapter (fn [^double a ^double b] (short 1)))
           (is (= (.methodDDS exerciser DDSadapter) "DDS"))
           (def LDSadapter (fn [^long a ^double b] (short 1)))
           (is (= (.methodLDS exerciser LDSadapter) "LDS"))
           (def DLSadapter (fn [^double a ^long b] (short 1)))
           (is (= (.methodDLS exerciser DLSadapter) "DLS"))
           (def OOSadapter (fn [^AdapterExerciser a ^AdapterExerciser b] (short 1)))
           (is (= (.methodOOS exerciser OOSadapter) "OOS"))
           (def ODSadapter (fn [^AdapterExerciser a ^double b] (short 1)))
           (is (= (.methodODS exerciser ODSadapter) "ODS"))
           (def DOSadapter (fn [^double a ^AdapterExerciser b] (short 1)))
           (is (= (.methodDOS exerciser DOSadapter) "DOS"))
           (def LLBadapter (fn [^long a ^long b] (byte 1)))
           (is (= (.methodLLB exerciser LLBadapter) "LLB"))
           (def LOBadapter (fn [^long a ^AdapterExerciser b] (byte 1)))
           (is (= (.methodLOB exerciser LOBadapter) "LOB"))
           (def OLBadapter (fn [^AdapterExerciser a ^long b] (byte 1)))
           (is (= (.methodOLB exerciser OLBadapter) "OLB"))
           (def DDBadapter (fn [^double a ^double b] (byte 1)))
           (is (= (.methodDDB exerciser DDBadapter) "DDB"))
           (def LDBadapter (fn [^long a ^double b] (byte 1)))
           (is (= (.methodLDB exerciser LDBadapter) "LDB"))
           (def DLBadapter (fn [^double a ^long b] (byte 1)))
           (is (= (.methodDLB exerciser DLBadapter) "DLB"))
           (def OOBadapter (fn [^AdapterExerciser a ^AdapterExerciser b] (byte 1)))
           (is (= (.methodOOB exerciser OOBadapter) "OOB"))
           (def ODBadapter (fn [^AdapterExerciser a ^double b] (byte 1)))
           (is (= (.methodODB exerciser ODBadapter) "ODB"))
           (def DOBadapter (fn [^double a ^AdapterExerciser b] (byte 1)))
           (is (= (.methodDOB exerciser DOBadapter) "DOB"))
           (def LLDadapter (fn [^long a ^long b] (double 1)))
           (is (= (.methodLLD exerciser LLDadapter) "LLD"))
           (def LODadapter (fn [^long a ^AdapterExerciser b] (double 1)))
           (is (= (.methodLOD exerciser LODadapter) "LOD"))
           (def OLDadapter (fn [^AdapterExerciser a ^long b] (double 1)))
           (is (= (.methodOLD exerciser OLDadapter) "OLD"))
           (def DDDadapter (fn [^double a ^double b] (double 1)))
           (is (= (.methodDDD exerciser DDDadapter) "DDD"))
           (def LDDadapter (fn [^long a ^double b] (double 1)))
           (is (= (.methodLDD exerciser LDDadapter) "LDD"))
           (def DLDadapter (fn [^double a ^long b] (double 1)))
           (is (= (.methodDLD exerciser DLDadapter) "DLD"))
           (def OODadapter (fn [^AdapterExerciser a ^AdapterExerciser b] (double 1)))
           (is (= (.methodOOD exerciser OODadapter) "OOD"))
           (def ODDadapter (fn [^AdapterExerciser a ^double b] (double 1)))
           (is (= (.methodODD exerciser ODDadapter) "ODD"))
           (def DODadapter (fn [^double a ^AdapterExerciser b] (double 1)))
           (is (= (.methodDOD exerciser DODadapter) "DOD"))
           (def LLFadapter (fn [^long a ^long b] (float 1)))
           (is (= (.methodLLF exerciser LLFadapter) "LLF"))
           (def LOFadapter (fn [^long a ^AdapterExerciser b] (float 1)))
           (is (= (.methodLOF exerciser LOFadapter) "LOF"))
           (def OLFadapter (fn [^AdapterExerciser a ^long b] (float 1)))
           (is (= (.methodOLF exerciser OLFadapter) "OLF"))
           (def DDFadapter (fn [^double a ^double b] (float 1)))
           (is (= (.methodDDF exerciser DDFadapter) "DDF"))
           (def LDFadapter (fn [^long a ^double b] (float 1)))
           (is (= (.methodLDF exerciser LDFadapter) "LDF"))
           (def DLFadapter (fn [^double a ^long b] (float 1)))
           (is (= (.methodDLF exerciser DLFadapter) "DLF"))
           (def OOFadapter (fn [^AdapterExerciser a ^AdapterExerciser b] (float 1)))
           (is (= (.methodOOF exerciser OOFadapter) "OOF"))
           (def ODFadapter (fn [^AdapterExerciser a ^double b] (float 1)))
           (is (= (.methodODF exerciser ODFadapter) "ODF"))
           (def DOFadapter (fn [^double a ^AdapterExerciser b] (float 1)))
           (is (= (.methodDOF exerciser DOFadapter) "DOF"))
           (def LLOadapter (fn [^long a ^long b] exerciser))
           (is (= (.methodLLO exerciser LLOadapter) "LLO"))
           (def LOOadapter (fn [^long a ^AdapterExerciser b] exerciser))
           (is (= (.methodLOO exerciser LOOadapter) "LOO"))
           (def OLOadapter (fn [^AdapterExerciser a ^long b] exerciser))
           (is (= (.methodOLO exerciser OLOadapter) "OLO"))
           (def DDOadapter (fn [^double a ^double b] exerciser))
           (is (= (.methodDDO exerciser DDOadapter) "DDO"))
           (def LDOadapter (fn [^long a ^double b] exerciser))
           (is (= (.methodLDO exerciser LDOadapter) "LDO"))
           (def DLOadapter (fn [^double a ^long b] exerciser))
           (is (= (.methodDLO exerciser DLOadapter) "DLO"))
           (def OOOadapter (fn [^AdapterExerciser a ^AdapterExerciser b] exerciser))
           (is (= (.methodOOO exerciser OOOadapter) "OOO"))
           (def ODOadapter (fn [^AdapterExerciser a ^double b] exerciser))
           (is (= (.methodODO exerciser ODOadapter) "ODO"))
           (def DOOadapter (fn [^double a ^AdapterExerciser b] exerciser))
           (is (= (.methodDOO exerciser DOOadapter) "DOO"))
           (def OOOOadapter (fn [^AdapterExerciser a ^AdapterExerciser b ^AdapterExerciser c] exerciser))
           (is (= (.methodOOOO exerciser OOOOadapter) "OOOO"))
           (def OOOOOadapter (fn [^AdapterExerciser a ^AdapterExerciser b ^AdapterExerciser c ^AdapterExerciser d] exerciser))
           (is (= (.methodOOOOO exerciser OOOOOadapter) "OOOOO"))
           (def OOOOOOadapter (fn [^AdapterExerciser a ^AdapterExerciser b ^AdapterExerciser c ^AdapterExerciser d ^AdapterExerciser e] exerciser))
           (is (= (.methodOOOOOO exerciser OOOOOOadapter) "OOOOOO"))
           (def OOOOOOOadapter (fn [^AdapterExerciser a ^AdapterExerciser b ^AdapterExerciser c ^AdapterExerciser d ^AdapterExerciser e ^AdapterExerciser f] exerciser))
           (is (= (.methodOOOOOOO exerciser OOOOOOOadapter) "OOOOOOO"))
           (def OOOOOOOOadapter (fn [^AdapterExerciser a ^AdapterExerciser b ^AdapterExerciser c ^AdapterExerciser d ^AdapterExerciser e ^AdapterExerciser f ^AdapterExerciser g] exerciser))
           (is (= (.methodOOOOOOOO exerciser OOOOOOOOadapter) "OOOOOOOO"))
           (def OOOOOOOOOadapter (fn [^AdapterExerciser a ^AdapterExerciser b ^AdapterExerciser c ^AdapterExerciser d ^AdapterExerciser e ^AdapterExerciser f ^AdapterExerciser g ^AdapterExerciser h] exerciser))
           (is (= (.methodOOOOOOOOO exerciser OOOOOOOOOadapter) "OOOOOOOOO"))
           (def OOOOOOOOOOadapter (fn [^AdapterExerciser a ^AdapterExerciser b ^AdapterExerciser c ^AdapterExerciser d ^AdapterExerciser e ^AdapterExerciser f ^AdapterExerciser g ^AdapterExerciser h ^AdapterExerciser i] exerciser))
           (is (= (.methodOOOOOOOOOO exerciser OOOOOOOOOOadapter) "OOOOOOOOOO"))
           (def OOOOOOOOOOOadapter (fn [^AdapterExerciser a ^AdapterExerciser b ^AdapterExerciser c ^AdapterExerciser d ^AdapterExerciser e ^AdapterExerciser f ^AdapterExerciser g ^AdapterExerciser h ^AdapterExerciser i ^AdapterExerciser j] exerciser))
           (is (= (.methodOOOOOOOOOOO exerciser OOOOOOOOOOOadapter) "OOOOOOOOOOO")))