     
     // MARK: - Public
     
-    public func registerVersions<T: RawRepresentable where T.RawValue == Version>(versions: [T]) throws {
+    public func registerVersions<T: RawRepresentable>(_ versions: [T]) throws where T.RawValue == Version {
         guard let firstVersion = versions.first else {
-            throw GollumError.EmptyVersionArrayPassed("A empty version array was passed to registered.")
+            throw GollumError.emptyVersionArrayPassed("A empty version array was passed to registered.")
         }
         
         let testName = extractTestName(firstVersion)

    
    // MARK: - Private
    
    private func extractTestName<T: RawRepresentable where T.RawValue == Version>(versionType: T) -> String {
        let mirror = Mirror(reflecting: versionType)
        return mirror.subjectName
    }
    
    private func raffleVersion<T: RawRepresentable where T.RawValue == Version>(versions: [T], testName: String) throws {
        let versionsRawValue = convertToArrayOfRawValue(versions)
        
        guard isTestProbabilitySumValid(versionsRawValue) else {
            throw GollumError.ProbabilitySumIncorrect("Sum of \(testName)'s probability isn't 1.0")
        }

        var selectedNumber = generateAleatoryNumber()
        let probabilities = versionsRawValue.map { Int($0.probability * 1000) }
        for (index, probability) in probabilities.enumerate() {
            if selectedNumber <= probability {
                selectedVersions[testName] = versionsRawValue[index]
                return

            try raffleVersion(versions, testName: testName)
            
            guard let selectedVersions = selectedVersions[testName] else {
                throw GollumError.selectedVersionNotFound("Test \(testName) should have a selected version.")
            }
            
            versionDAO.saveSelectedVersion(selectedVersions, testName: testName)
        }
    }
    
    public func getSelectedVersion<T: RawRepresentable>(_ test: T.Type) throws -> T where T.RawValue == Version {
        let testName = String(describing: test)
        
        guard let rawValue = selectedVersions[testName],
            let version = test.init(rawValue: rawValue) else {
                throw GollumError.selectedVersionNotFound("Test \(testName) should have a selected version.")
        }
        
        return version
    }
    
    public func isVersionSelected<T: RawRepresentable>(_ version: T) throws -> Bool where T.RawValue == Version {
        let testName = extractTestName(version)
        
        guard let selectedVersion = selectedVersions[testName] else {
            throw GollumError.selectedVersionNotFound("Test \(testName) should have a selected version.")
        }
        
        return selectedVersion == version.rawValue
