lazarevzubov's questions

É mais fácil explicar o problema em um exemplo. Por exemplo, considere esta classe genérica simples:

final class GenericClass<T> {
  private let parameter: T
  init(parameter: T) {
    self.parameter = parameter
  }
}

Quero adicionar um vazio initem uma extensão, quando Tfor any Array(ou mesmo Collection, mas não é crucial para o meu caso). Quero algo assim, mas não compila:

// Reference to generic type 'Array' requires arguments in <...>
extension GenericClass where T: Array {
  convenience init() {
    // Cannot convert value of type '[Any]' to expected argument type 'T'
    self.init(parameter: [])
  }
}

Como posso adicionar um parâmetro genérico ao Array? Esta sintaxe não funciona:

extension GenericClass<U> where T: Array<U> { // Cannot find type 'U' in scope
  convenience init() {
    self.init(parameter: [U]()) // Cannot call value of non-function type '[Any]'
  }
}

( T == Array<U>também não funciona.)

Existe alguma maneira de conseguir o que descrevi? Eu realmente gostaria de evitar declarar extensões separadas para cada tipo de elemento que preciso (claro que o código abaixo funciona perfeitamente):

extension GenericClass where T == [Int] {
  convenience init() {
    self.init(parameter: [])
  }
}

Às vezes, tenho que escrever testes que validam que algum valor muda eventualmente. Isso acontece, por exemplo, se eu preciso lidar com concorrência não estruturada. Aqui está um exemplo desse tipo de teste no XCTest:

let predicate = NSPredicate { service, _ in
    guard let service = service as? SomeService else {
        return false
    }
    return service.something == expectedValue
}
let expectation = XCTNSPredicateExpectation(predicate: predicate, object: service)

sut.doSomething(expectedValue)

wait(for: [expectation], timeout: 1.0)

Como seria possível escrever tais testes em Testes?

Considere este teste de unidade baseado no XCTest:

func testImageRetrieved() {
  let expectation = XCTestExpectation()
  let cancellable = viewModel.$image.dropFirst().sink { _ in
    // Do nothing on completion.
  } receiveValue: {
    XCTAssertNotNil($0)
    expectation.fulfill()
  }
  wait(for: [expectation], timeout: 1.0)

  cancellable.cancel()
}

De acordo com o Migrating a test from XCTest da Apple , isso deve ser diretamente traduzível neste método baseado em testes Swift:

@Test
func imageRetrieved() async {
  var cancellable: AnyCancellable?
  await confirmation { imageRetrieved in
    cancellable = viewModel.$image.dropFirst().sink { _ in
      // Do nothing on completion.
    } receiveValue: {
      #expect($0 != nil)
      imageRetrieved()
    }
  }
  cancellable?.cancel()
}

O último teste, no entanto, falha com o erro dizendo: "A confirmação foi confirmada 0 vezes, mas esperava-se que fosse confirmada 1 vez". Parece que a confirmação não "espera" até que o publicador emita um valor.

Qual é a maneira correta de testar editores do Combine no Swift Testing?

No meu aplicativo, tenho ScrollViewuma subvisão estática como cabeçalho e uma LazyVStackcom vários elementos preenchidos com dados do modelo de visualização. Além disso, se esses dados "dinâmicos" estiverem vazios, em vez de LazyVStack, mostro uma visualização de espaço reservado. Aqui está uma estrutura simplificada da visualização:

var body: some View {
  GeometryReader { geometry in
    ScrollView {
      HStack(spacing: .zero) {
        Text("This is my greeting to you")
        Spacer()
      }
      if greetings.isEmpty {
        PlaceholderView()
          .frame(height: geometry.size.height)
      } else {
        LazyVStack {
          ForEach(greetings, id: \.self) {
            Text($0)
          }
        }
      }
    }
  }
}
private var greetings: [String]

PlaceholderView:

VStack {
  Image(systemName: "hand.wave")
  Text("Hello world!")
}

Quero PlaceholderViewser exibido no meio do espaço disponível (ou seja, neste caso, toda a altura da tela menos a altura da HStackparte superior). Muitas perguntas semelhantes aqui sugerem o uso GeometryReader, mas não ajuda neste caso :

GeometryReader { geometry in
  ScrollView {
    HStack(spacing: .zero) {
      Text("This is my greetings to you")
      Spacer()
    }
    if greetings.isEmpty {
      ExampleView()
        .frame(height: geometry.size.height)
    } else {
      LazyVStack {
        ForEach(greetings, id: \.self) {
          Text($0)
        }
      }
    }
  }
}

Usar o código acima PlaceholderViewocupa mais espaço do que o necessário. No meu caso, deveria ser algo como geometry.size.height - hStackHeight:

Existe uma maneira de obter PlaceholderViewexatamente a altura da tela menos HStacka altura de? Qualquer orientação é muito apreciada.