DictionarySubscriptDefault.swift

//===--- DictionarySubscriptDefault.swift ---------------------------------===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2021 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//

import TestsUtils

publicletbenchmarks=[
BenchmarkInfo(name:"DictionarySubscriptDefaultMutation",
 runFunction: run_DictionarySubscriptDefaultMutation,
 tags:[.validation,.api,.Dictionary]),
BenchmarkInfo(name:"DictionarySubscriptDefaultMutationArray",
 runFunction: run_DictionarySubscriptDefaultMutationArray,
 tags:[.validation,.api,.Dictionary]),
BenchmarkInfo(name:"DictionarySubscriptDefaultMutationOfObjects",
 runFunction: run_DictionarySubscriptDefaultMutationOfObjects,
 tags:[.validation,.api,.Dictionary], legacyFactor:20),
BenchmarkInfo(name:"DictionarySubscriptDefaultMutationArrayOfObjects",
 runFunction:
 run_DictionarySubscriptDefaultMutationArrayOfObjects,
 tags:[.validation,.api,.Dictionary], legacyFactor:20),
]

@inline(never)
publicfunc run_DictionarySubscriptDefaultMutation(_ n:Int){
for_in1...n {

vardict=[Int: Int]()

foriin0..<10_000{
dict[i %100, default:0]+=1
}

check(dict.count ==100)
check(dict[0]! ==100)
}
}

@inline(never)
publicfunc run_DictionarySubscriptDefaultMutationArray(_ n:Int){
for_in1...n {

vardict=[Int:[Int]]()

foriin0..<10_000{
dict[i %100, default:[]].append(i)
}

check(dict.count ==100)
check(dict[0]!.count ==100)
}
}

// Hack to workaround the fact that if we attempt to increment the Box's value
// from the subscript, the compiler will just call the subscript's getter (and
// therefore not insert the instance) as it's dealing with a reference type.
// By using a mutating method in a protocol extension, the compiler is forced to
// treat this an actual mutation, so cannot call the getter.
protocolP{
associatedtypeT
varvalue:T{getset}
}

extensionP{
mutatingfunc mutateValue(_ mutations:(inoutT)->Void){
mutations(&value)
}
}

classBox<T :Hashable>:Hashable,P{
varvalue:T

init(_ v:T){
 value = v
}

func hash(into hasher:inoutHasher){
 hasher.combine(value)
}

staticfunc==(lhs:Box, rhs:Box)->Bool{
return lhs.value == rhs.value
}
}

@inline(never)
publicfunc run_DictionarySubscriptDefaultMutationOfObjects(_ n:Int){
for_in1...n {

vardict=[Box<Int>:Box<Int>]()

foriin0..<500{
dict[Box(i %5), default:Box(0)].mutateValue{ $0 +=1}
}

check(dict.count ==5)
check(dict[Box(0)]!.value ==100)
}
}

@inline(never)
publicfunc run_DictionarySubscriptDefaultMutationArrayOfObjects(_ n:Int){
for_in1...n {

vardict=[Box<Int>:[Box<Int>]]()

foriin0..<500{
dict[Box(i %5), default:[]].append(Box(i))
}

check(dict.count ==5)
check(dict[Box(0)]!.count ==100)
}
}