// Copyright (c) 2013, the Dart project authors. Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.

// @dart = 2.9

// Client for secure_bad_certificate_test, that runs in a subprocess.
// The test verifies that the client bad certificate callback works.

import "dart:async";
import "dart:io";

String localFile(path) => Platform.script.resolve(path).toFilePath();

SecurityContext clientContext = new SecurityContext()
  ..setTrustedCertificates(localFile('certificates/trusted_certs.pem'));

class ExpectException implements Exception {
  ExpectException(this.message);
  String toString() => "ExpectException: $message";
  String message;
}

void expect(condition) {
  if (!condition) {
    throw new ExpectException('');
  }
}

const HOST_NAME = "localhost";

Future runClients(int port) {
  var testFutures = <Future>[];
  for (int i = 0; i < 20; ++i) {
    testFutures.add(SecureSocket
        .connect(HOST_NAME, port, context: clientContext)
        .then((SecureSocket socket) {
      expect(false);
    }, onError: (e) {
      expect(e is HandshakeException || e is SocketException);
    }));
  }
  return Future.wait(testFutures);
}

void main(List<String> args) {
  runClients(int.parse(args[0])).then((_) => print('SUCCESS'));
}
