src/php/tests/unit_tests/PersistentChannelTests/PersistentChannelTest.php - third_party/grpc - Git at Google


            
            <?php

            
            /*

            
             *

            
             * Copyright 2015 gRPC authors.

            
             *

            
             * Licensed under the Apache License, Version 2.0 (the "License");

            
             * you may not use this file except in compliance with the License.

            
             * You may obtain a copy of the License at

            
             *

            
             *     http://www.apache.org/licenses/LICENSE-2.0

            
             *

            
             * Unless required by applicable law or agreed to in writing, software

            
             * distributed under the License is distributed on an "AS IS" BASIS,

            
             * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

            
             * See the License for the specific language governing permissions and

            
             * limitations under the License.

            
             *

            
             */


            /**

            
             * @group persistent_list_bound_tests

            
             */

            
            class PersistentChannelTest extends \PHPUnit\Framework\TestCase

            
            {

            
              public function setUp(): void

            
              {

            
              }


              public function tearDown(): void

            
              {

            
                $channel_clean_persistent =

            
                    new Grpc\Channel('localhost:50010', []);

            
                $plist = $channel_clean_persistent->getPersistentList();

            
                $channel_clean_persistent->cleanPersistentList();

            
              }


              public function waitUntilNotIdle($channel) {

            
                  for ($i = 0; $i < 10; $i++) {

            
                      $now = Grpc\Timeval::now();

            
                      $deadline = $now->add(new Grpc\Timeval(1000));

            
                      if ($channel->watchConnectivityState(GRPC\CHANNEL_IDLE,

            
                          $deadline)) {

            
                          return true;

            
                      }

            
                  }

            
                  $this->assertTrue(false);

            
              }


              public function assertConnecting($state) {

            
                  $this->assertTrue($state == GRPC\CHANNEL_CONNECTING ||

            
                  $state == GRPC\CHANNEL_TRANSIENT_FAILURE);

            
              }


              public function testInitHelper()

            
              {

            
                  // PersistentList is not empty at the beginning of the tests

            
                  // because phpunit will cache the channels created by other test

            
                  // files.

            
              }


              public function testChannelNotPersist()

            
              {

            
                  $this->channel1 = new Grpc\Channel('localhost:1', ['force_new' => true]);

            
                  $channel1_info = $this->channel1->getChannelInfo();

            
                  $plist_info = $this->channel1->getPersistentList();

            
                  $this->assertEquals($channel1_info['target'], 'localhost:1');

            
                  $this->assertEquals($channel1_info['ref_count'], 1);

            
                  $this->assertEquals($channel1_info['connectivity_status'],

            
                      GRPC\CHANNEL_IDLE);

            
                  $this->assertEquals(count($plist_info), 0);

            
                  $this->channel1->close();

            
              }


              public function testPersistentChannelCreateOneChannel()

            
              {

            
                  $this->channel1 = new Grpc\Channel('localhost:1', []);

            
                  $channel1_info = $this->channel1->getChannelInfo();

            
                  $plist_info = $this->channel1->getPersistentList();

            
                  $this->assertEquals($channel1_info['target'], 'localhost:1');

            
                  $this->assertEquals($channel1_info['ref_count'], 2);

            
                  $this->assertEquals($channel1_info['connectivity_status'],

            
                                      GRPC\CHANNEL_IDLE);

            
                  $this->assertArrayHasKey($channel1_info['key'], $plist_info);

            
                  $this->assertEquals(count($plist_info), 1);

            
                  $this->channel1->close();

            
              }


              public function testPersistentChannelCreateMultipleChannels()

            
              {

            
                  $this->channel1 = new Grpc\Channel('localhost:1', []);

            
                  $plist_info = $this->channel1->getPersistentList();

            
                  $this->assertEquals(count($plist_info), 1);


                  $this->channel2 = new Grpc\Channel('localhost:2', []);

            
                  $plist_info = $this->channel1->getPersistentList();

            
                  $this->assertEquals(count($plist_info), 2);


                  $this->channel3 = new Grpc\Channel('localhost:3', []);

            
                  $plist_info = $this->channel1->getPersistentList();

            
                  $this->assertEquals(count($plist_info), 3);

            
              }


              public function testPersistentChannelStatusChange()

            
              {

            
                  $this->channel1 = new Grpc\Channel('localhost:4', []);

            
                  $channel1_info = $this->channel1->getChannelInfo();

            
                  $this->assertEquals($channel1_info['connectivity_status'],

            
                                      GRPC\CHANNEL_IDLE);


                  $this->channel1->getConnectivityState(true);

            
                  $this->waitUntilNotIdle($this->channel1);

            
                  $channel1_info = $this->channel1->getChannelInfo();

            
                  $this->assertConnecting($channel1_info['connectivity_status']);

            
                  $this->channel1->close();

            
              }


              public function testPersistentChannelCloseChannel()

            
              {

            
                  $this->channel1 = new Grpc\Channel('localhost:1', []);

            
                  $this->channel2 = new Grpc\Channel('localhost:1', []);


                  $channel1_info = $this->channel1->getChannelInfo();

            
                  $this->assertEquals($channel1_info['ref_count'], 3);

            
                  $plist_info = $this->channel1->getPersistentList();

            
                  $this->assertEquals($plist_info[$channel1_info['key']]['ref_count'], 3);


                  $this->channel1->close();

            
                  $plist_info = $this->channel1->getPersistentList();

            
                  $this->assertEquals($plist_info[$channel1_info['key']]['ref_count'], 2);


                  $this->channel2->close();

            
                  $plist_info = $this->channel1->getPersistentList();

            
                  $this->assertEquals($plist_info[$channel1_info['key']]['ref_count'], 1);

            
              }


              public function testPersistentChannelSameTarget()

            
              {

            
                  $this->channel1 = new Grpc\Channel('localhost:1', []);

            
                  $this->channel2 = new Grpc\Channel('localhost:1', []);

            
                  $plist = $this->channel2->getPersistentList();

            
                  $channel1_info = $this->channel1->getChannelInfo();

            
                  $channel2_info = $this->channel2->getChannelInfo();

            
                  // $channel1 and $channel2 shares the same channel, thus only 1

            
                  // channel should be in the persistent list.

            
                  $this->assertEquals($channel1_info['key'], $channel2_info['key']);

            
                  $this->assertArrayHasKey($channel1_info['key'], $plist);

            
                  $this->assertEquals(count($plist), 1);

            
                  $this->channel1->close();

            
                  $this->channel2->close();

            
              }


              public function testPersistentChannelDifferentTarget()

            
              {

            
                  $this->channel1 = new Grpc\Channel('localhost:1', []);

            
                  $channel1_info = $this->channel1->getChannelInfo();

            
                  $this->channel2 = new Grpc\Channel('localhost:2', []);

            
                  $channel2_info = $this->channel1->getChannelInfo();

            
                  $plist_info = $this->channel1->getPersistentList();

            
                  $this->assertArrayHasKey($channel1_info['key'], $plist_info);

            
                  $this->assertArrayHasKey($channel2_info['key'], $plist_info);

            
                  $this->assertEquals($plist_info[$channel1_info['key']]['ref_count'], 2);

            
                  $this->assertEquals($plist_info[$channel2_info['key']]['ref_count'], 2);

            
                  $plist_info = $this->channel1->getPersistentList();

            
                  $this->assertEquals(count($plist_info), 2);

            
                  $this->channel1->close();

            
                  $this->channel2->close();

            
              }


              public function testPersistentChannelSharedChannelClose()

            
              {

            
                $this->expectException(\RuntimeException::class);

            
                $this->expectExceptionMessage("startBatch Error. Channel is closed");

            
                // same underlying channel

            
                  $this->channel1 = new Grpc\Channel('localhost:10001', [

            
                      "grpc_target_persist_bound" => 2,

            
                  ]);

            
                  $this->channel2 = new Grpc\Channel('localhost:10001', []);

            
                  $this->server = new Grpc\Server([]);

            
                  $this->port = $this->server->addHttp2Port('localhost:10001');

            
                  $this->server->start();


                  // channel2 can still be use

            
                  $state = $this->channel2->getConnectivityState();

            
                  $this->assertEquals(GRPC\CHANNEL_IDLE, $state);


                  $call1 = new Grpc\Call($this->channel1,

            
                      '/foo',

            
                      Grpc\Timeval::infFuture());

            
                  $call2 = new Grpc\Call($this->channel2,

            
                      '/foo',

            
                      Grpc\Timeval::infFuture());

            
                  $call3 = new Grpc\Call($this->channel1,

            
                      '/foo',

            
                      Grpc\Timeval::infFuture());

            
                  $call4 = new Grpc\Call($this->channel2,

            
                      '/foo',

            
                      Grpc\Timeval::infFuture());

            
                  $batch = [

            
                      Grpc\OP_SEND_INITIAL_METADATA => [],

            
                  ];


                  $result = $call1->startBatch($batch);

            
                  $this->assertTrue($result->send_metadata);

            
                  $result = $call2->startBatch($batch);

            
                  $this->assertTrue($result->send_metadata);


                  $this->channel1->close();

            
                  // After closing channel1, channel2 can still be use

            
                  $result = $call4->startBatch($batch);

            
                  $this->assertTrue($result->send_metadata);

            
                  // channel 1 is closed, it will throw an exception.

            
                  $result = $call3->startBatch($batch);

            
              }


              public function testPersistentChannelTargetDefaultUpperBound()

            
              {

            
                  $this->channel1 = new Grpc\Channel('localhost:10002', []);

            
                  $channel1_info = $this->channel1->getChannelInfo();

            
                  $this->assertEquals($channel1_info['target_upper_bound'], 1);

            
                  $this->assertEquals($channel1_info['target_current_size'], 1);

            
              }


              public function testPersistentChannelTargetUpperBoundZero()

            
              {

            
                  $this->channel1 = new Grpc\Channel('localhost:10002', [

            
                      "grpc_target_persist_bound" => 0,

            
                  ]);

            
                  // channel1 will not be persisted.

            
                  $channel1_info = $this->channel1->getChannelInfo();

            
                  $this->assertEquals($channel1_info['target_upper_bound'], 0);

            
                  $this->assertEquals($channel1_info['target_current_size'], 0);

            
                  $plist_info = $this->channel1->getPersistentList();

            
                  $this->assertEquals(0, count($plist_info));

            
              }


              public function testPersistentChannelTargetUpperBoundNotZero()

            
              {

            
                  $this->channel1 = new Grpc\Channel('localhost:10003', [

            
                      "grpc_target_persist_bound" => 3,

            
                  ]);

            
                  $channel1_info = $this->channel1->getChannelInfo();

            
                  $this->assertEquals($channel1_info['target_upper_bound'], 3);

            
                  $this->assertEquals($channel1_info['target_current_size'], 1);


                  // The upper bound should not be changed

            
                  $this->channel2 = new Grpc\Channel('localhost:10003', []);

            
                  $channel2_info = $this->channel2->getChannelInfo();

            
                  $this->assertEquals($channel2_info['target_upper_bound'], 3);

            
                  $this->assertEquals($channel2_info['target_current_size'], 1);


                  // The upper bound should not be changed

            
                  $channel_credentials = Grpc\ChannelCredentials::createSsl(null, null,

            
                      null);

            
                  $this->channel3 = new Grpc\Channel('localhost:10003',

            
                      ['credentials' => $channel_credentials]);

            
                  $channel3_info = $this->channel3->getChannelInfo();

            
                  $this->assertEquals($channel3_info['target_upper_bound'], 3);

            
                  $this->assertEquals($channel3_info['target_current_size'], 2);


                  // The upper bound should not be changed

            
                  $this->channel4 = new Grpc\Channel('localhost:10003', [

            
                      "grpc_target_persist_bound" => 5,

            
                  ]);

            
                  $channel4_info = $this->channel4->getChannelInfo();

            
                  $this->assertEquals($channel4_info['target_upper_bound'], 5);

            
                  $this->assertEquals($channel4_info['target_current_size'], 2);

            
              }


              public function testPersistentChannelDefaultOutBound1()

            
              {

            
                  $this->channel1 = new Grpc\Channel('localhost:10004', []);

            
                  // Make channel1 not IDLE.

            
                  $this->channel1->getConnectivityState(true);

            
                  $this->waitUntilNotIdle($this->channel1);

            
                  $channel1_info = $this->channel1->getChannelInfo();

            
                  $this->assertConnecting($channel1_info['connectivity_status']);


                  // Since channel1 is CONNECTING, channel 2 will not be persisted

            
                  $channel_credentials = Grpc\ChannelCredentials::createSsl(null, null,

            
                    null);

            
                  $this->channel2 = new Grpc\Channel('localhost:10004',

            
                      ['credentials' => $channel_credentials]);

            
                  $channel2_info = $this->channel2->getChannelInfo();

            
                  $this->assertEquals(GRPC\CHANNEL_IDLE, $channel2_info['connectivity_status']);


                  // By default, target 'localhost:10011' only persist one channel.

            
                  // Since channel1 is not Idle channel2 will not be persisted.

            
                  $plist_info = $this->channel1->getPersistentList();

            
                  $this->assertEquals(1, count($plist_info));

            
                  $this->assertArrayHasKey($channel1_info['key'], $plist_info);

            
                  $this->assertArrayNotHasKey($channel2_info['key'], $plist_info);

            
              }


              public function testPersistentChannelDefaultOutBound2()

            
              {

            
                  $this->channel1 = new Grpc\Channel('localhost:10005', []);

            
                  $channel1_info = $this->channel1->getChannelInfo();

            
                  $this->assertEquals(GRPC\CHANNEL_IDLE, $channel1_info['connectivity_status']);


                  // Although channel1 is IDLE, channel1 still has reference to the underline

            
                  // gRPC channel. channel2 will not be persisted

            
                  $channel_credentials = Grpc\ChannelCredentials::createSsl(null, null,

            
                    null);

            
                  $this->channel2 = new Grpc\Channel('localhost:10005',

            
                      ['credentials' => $channel_credentials]);

            
                  $channel2_info = $this->channel2->getChannelInfo();

            
                  $this->assertEquals(GRPC\CHANNEL_IDLE, $channel2_info['connectivity_status']);


                  // By default, target 'localhost:10011' only persist one channel.

            
                  // Since channel1 Idle, channel2 will be persisted.

            
                  $plist_info = $this->channel1->getPersistentList();

            
                  $this->assertEquals(1, count($plist_info));

            
                  $this->assertArrayHasKey($channel1_info['key'], $plist_info);

            
                  $this->assertArrayNotHasKey($channel2_info['key'], $plist_info);

            
              }


              public function testPersistentChannelDefaultOutBound3()

            
              {

            
                  $this->channel1 = new Grpc\Channel('localhost:10006', []);

            
                  $channel1_info = $this->channel1->getChannelInfo();

            
                  $this->assertEquals(GRPC\CHANNEL_IDLE, $channel1_info['connectivity_status']);


                  $this->channel1->close();

            
                  // channel1 is closed, no reference holds to the underline channel.

            
                  // channel2 can be persisted.

            
                  $channel_credentials = Grpc\ChannelCredentials::createSsl(null, null,

            
                    null);

            
                  $this->channel2 = new Grpc\Channel('localhost:10006',

            
                    ['credentials' => $channel_credentials]);

            
                  $channel2_info = $this->channel2->getChannelInfo();

            
                  $this->assertEquals(GRPC\CHANNEL_IDLE, $channel2_info['connectivity_status']);


                  // By default, target 'localhost:10011' only persist one channel.

            
                  // Since channel1 Idle, channel2 will be persisted.

            
                  $plist_info = $this->channel2->getPersistentList();

            
                  $this->assertEquals(1, count($plist_info));

            
                  $this->assertArrayHasKey($channel2_info['key'], $plist_info);

            
                  $this->assertArrayNotHasKey($channel1_info['key'], $plist_info);

            
              }


              public function testPersistentChannelTwoUpperBound()

            
              {

            
                  $this->channel1 = new Grpc\Channel('localhost:10007', [

            
                      "grpc_target_persist_bound" => 2,

            
                  ]);

            
                  $channel1_info = $this->channel1->getChannelInfo();

            
                  $this->assertEquals(GRPC\CHANNEL_IDLE, $channel1_info['connectivity_status']);


                  // Since channel1 is IDLE, channel 1 will be deleted

            
                  $channel_credentials = Grpc\ChannelCredentials::createSsl(null, null,

            
                      null);

            
                  $this->channel2 = new Grpc\Channel('localhost:10007',

            
                      ['credentials' => $channel_credentials]);

            
                  $channel2_info = $this->channel2->getChannelInfo();

            
                  $this->assertEquals(GRPC\CHANNEL_IDLE, $channel2_info['connectivity_status']);


                  $plist_info = $this->channel1->getPersistentList();

            
                  $this->assertEquals(2, count($plist_info));

            
                  $this->assertArrayHasKey($channel1_info['key'], $plist_info);

            
                  $this->assertArrayHasKey($channel2_info['key'], $plist_info);

            
              }


              public function testPersistentChannelTwoUpperBoundOutBound1()

            
              {

            
                  $this->channel1 = new Grpc\Channel('localhost:10011', [

            
                      "grpc_target_persist_bound" => 2,

            
                  ]);

            
                  $channel1_info = $this->channel1->getChannelInfo();


                  $channel_credentials = Grpc\ChannelCredentials::createSsl(null, null,

            
                    null);

            
                  $this->channel2 = new Grpc\Channel('localhost:10011',

            
                      ['credentials' => $channel_credentials]);

            
                  $channel2_info = $this->channel2->getChannelInfo();


                  // Close channel1, so that new channel can be persisted.

            
                  $this->channel1->close();


                  $channel_credentials = Grpc\ChannelCredentials::createSsl("a", null,

            
                    null);

            
                  $this->channel3 = new Grpc\Channel('localhost:10011',

            
                      ['credentials' => $channel_credentials]);

            
                  $channel3_info = $this->channel3->getChannelInfo();


                  $plist_info = $this->channel1->getPersistentList();

            
                  $this->assertEquals(2, count($plist_info));

            
                  $this->assertArrayNotHasKey($channel1_info['key'], $plist_info);

            
                  $this->assertArrayHasKey($channel2_info['key'], $plist_info);

            
                  $this->assertArrayHasKey($channel3_info['key'], $plist_info);

            
              }


              public function testPersistentChannelTwoUpperBoundOutBound2()

            
              {

            
                  $this->channel1 = new Grpc\Channel('localhost:10012', [

            
                      "grpc_target_persist_bound" => 2,

            
                  ]);

            
                  $channel1_info = $this->channel1->getChannelInfo();


                  $channel_credentials = Grpc\ChannelCredentials::createSsl(null, null,

            
                    null);

            
                  $this->channel2 = new Grpc\Channel('localhost:10012',

            
                    ['credentials' => $channel_credentials]);

            
                  $channel2_info = $this->channel2->getChannelInfo();


                  // Close channel2, so that new channel can be persisted.

            
                  $this->channel2->close();


                  $channel_credentials = Grpc\ChannelCredentials::createSsl("a", null,

            
                    null);

            
                  $this->channel3 = new Grpc\Channel('localhost:10012',

            
                    ['credentials' => $channel_credentials]);

            
                  $channel3_info = $this->channel3->getChannelInfo();


                  $plist_info = $this->channel1->getPersistentList();

            
                  $this->assertEquals(2, count($plist_info));

            
                  $this->assertArrayHasKey($channel1_info['key'], $plist_info);

            
                  $this->assertArrayNotHasKey($channel2_info['key'], $plist_info);

            
                  $this->assertArrayHasKey($channel3_info['key'], $plist_info);

            
              }


              public function testPersistentChannelTwoUpperBoundOutBound3()

            
              {

            
                  $this->channel1 = new Grpc\Channel('localhost:10013', [

            
                      "grpc_target_persist_bound" => 2,

            
                  ]);

            
                  $channel1_info = $this->channel1->getChannelInfo();


                  $channel_credentials = Grpc\ChannelCredentials::createSsl(null, null,

            
                      null);

            
                  $this->channel2 = new Grpc\Channel('localhost:10013',

            
                      ['credentials' => $channel_credentials]);

            
                  $this->channel2->getConnectivityState(true);

            
                  $this->waitUntilNotIdle($this->channel2);

            
                  $channel2_info = $this->channel2->getChannelInfo();

            
                  $this->assertConnecting($channel2_info['connectivity_status']);


                  // Only one channel will be deleted

            
                  $this->channel1->close();

            
                  $this->channel2->close();


                  $channel_credentials = Grpc\ChannelCredentials::createSsl("a", null,

            
                    null);

            
                  $this->channel3 = new Grpc\Channel('localhost:10013',

            
                      ['credentials' => $channel_credentials]);

            
                  $channel3_info = $this->channel3->getChannelInfo();


                  // Only the Idle Channel will be deleted

            
                  $plist_info = $this->channel1->getPersistentList();

            
                  $this->assertEquals(2, count($plist_info));

            
                  $this->assertArrayNotHasKey($channel1_info['key'], $plist_info);

            
                  $this->assertArrayHasKey($channel2_info['key'], $plist_info);

            
                  $this->assertArrayHasKey($channel3_info['key'], $plist_info);

            
              }


              public function testPersistentChannelTwoUpperBoundOutBound4()

            
              {

            
                  $this->channel1 = new Grpc\Channel('localhost:10014', [

            
                      "grpc_target_persist_bound" => 2,

            
                  ]);

            
                  $this->channel1->getConnectivityState(true);

            
                  $this->waitUntilNotIdle($this->channel1);

            
                  $channel1_info = $this->channel1->getChannelInfo();

            
                  $this->assertConnecting($channel1_info['connectivity_status']);


                  $channel_credentials = Grpc\ChannelCredentials::createSsl(null, null,

            
                      null);

            
                  $this->channel2 = new Grpc\Channel('localhost:10014',

            
                      ['credentials' => $channel_credentials]);

            
                  $this->channel2->getConnectivityState(true);

            
                  $this->waitUntilNotIdle($this->channel2);

            
                  $channel2_info = $this->channel2->getChannelInfo();

            
                  $this->assertConnecting($channel2_info['connectivity_status']);


                  $channel_credentials = Grpc\ChannelCredentials::createSsl("a", null,

            
                      null);

            
                  $this->channel3 = new Grpc\Channel('localhost:10014',

            
                      ['credentials' => $channel_credentials]);

            
                  $channel3_info = $this->channel3->getChannelInfo();


                  // Channel3 will not be persisted

            
                  $plist_info = $this->channel1->getPersistentList();

            
                  $this->assertEquals(2, count($plist_info));

            
                  $this->assertArrayHasKey($channel1_info['key'], $plist_info);

            
                  $this->assertArrayHasKey($channel2_info['key'], $plist_info);

            
                  $this->assertArrayNotHasKey($channel3_info['key'], $plist_info);

            
              }

            
            }
	<?php
	/*
	*
	* Copyright 2015 gRPC authors.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*
	*/

	/**
	* @group persistent_list_bound_tests
	*/
	class PersistentChannelTest extends \PHPUnit\Framework\TestCase
	{
	public function setUp(): void
	{
	}

	public function tearDown(): void
	{
	$channel_clean_persistent =
	new Grpc\Channel('localhost:50010', []);
	$plist = $channel_clean_persistent->getPersistentList();
	$channel_clean_persistent->cleanPersistentList();
	}

	public function waitUntilNotIdle($channel) {
	for ($i = 0; $i < 10; $i++) {
	$now = Grpc\Timeval::now();
	$deadline = $now->add(new Grpc\Timeval(1000));
	if ($channel->watchConnectivityState(GRPC\CHANNEL_IDLE,
	$deadline)) {
	return true;
	}
	}
	$this->assertTrue(false);
	}

	public function assertConnecting($state) {
	$this->assertTrue($state == GRPC\CHANNEL_CONNECTING \|\|
	$state == GRPC\CHANNEL_TRANSIENT_FAILURE);
	}

	public function testInitHelper()
	{
	// PersistentList is not empty at the beginning of the tests
	// because phpunit will cache the channels created by other test
	// files.
	}


	public function testChannelNotPersist()
	{
	$this->channel1 = new Grpc\Channel('localhost:1', ['force_new' => true]);
	$channel1_info = $this->channel1->getChannelInfo();
	$plist_info = $this->channel1->getPersistentList();
	$this->assertEquals($channel1_info['target'], 'localhost:1');
	$this->assertEquals($channel1_info['ref_count'], 1);
	$this->assertEquals($channel1_info['connectivity_status'],
	GRPC\CHANNEL_IDLE);
	$this->assertEquals(count($plist_info), 0);
	$this->channel1->close();
	}

	public function testPersistentChannelCreateOneChannel()
	{
	$this->channel1 = new Grpc\Channel('localhost:1', []);
	$channel1_info = $this->channel1->getChannelInfo();
	$plist_info = $this->channel1->getPersistentList();
	$this->assertEquals($channel1_info['target'], 'localhost:1');
	$this->assertEquals($channel1_info['ref_count'], 2);
	$this->assertEquals($channel1_info['connectivity_status'],
	GRPC\CHANNEL_IDLE);
	$this->assertArrayHasKey($channel1_info['key'], $plist_info);
	$this->assertEquals(count($plist_info), 1);
	$this->channel1->close();
	}

	public function testPersistentChannelCreateMultipleChannels()
	{
	$this->channel1 = new Grpc\Channel('localhost:1', []);
	$plist_info = $this->channel1->getPersistentList();
	$this->assertEquals(count($plist_info), 1);

	$this->channel2 = new Grpc\Channel('localhost:2', []);
	$plist_info = $this->channel1->getPersistentList();
	$this->assertEquals(count($plist_info), 2);

	$this->channel3 = new Grpc\Channel('localhost:3', []);
	$plist_info = $this->channel1->getPersistentList();
	$this->assertEquals(count($plist_info), 3);
	}

	public function testPersistentChannelStatusChange()
	{
	$this->channel1 = new Grpc\Channel('localhost:4', []);
	$channel1_info = $this->channel1->getChannelInfo();
	$this->assertEquals($channel1_info['connectivity_status'],
	GRPC\CHANNEL_IDLE);

	$this->channel1->getConnectivityState(true);
	$this->waitUntilNotIdle($this->channel1);
	$channel1_info = $this->channel1->getChannelInfo();
	$this->assertConnecting($channel1_info['connectivity_status']);
	$this->channel1->close();
	}

	public function testPersistentChannelCloseChannel()
	{
	$this->channel1 = new Grpc\Channel('localhost:1', []);
	$this->channel2 = new Grpc\Channel('localhost:1', []);

	$channel1_info = $this->channel1->getChannelInfo();
	$this->assertEquals($channel1_info['ref_count'], 3);
	$plist_info = $this->channel1->getPersistentList();
	$this->assertEquals($plist_info[$channel1_info['key']]['ref_count'], 3);

	$this->channel1->close();
	$plist_info = $this->channel1->getPersistentList();
	$this->assertEquals($plist_info[$channel1_info['key']]['ref_count'], 2);

	$this->channel2->close();
	$plist_info = $this->channel1->getPersistentList();
	$this->assertEquals($plist_info[$channel1_info['key']]['ref_count'], 1);
	}

	public function testPersistentChannelSameTarget()
	{
	$this->channel1 = new Grpc\Channel('localhost:1', []);
	$this->channel2 = new Grpc\Channel('localhost:1', []);
	$plist = $this->channel2->getPersistentList();
	$channel1_info = $this->channel1->getChannelInfo();
	$channel2_info = $this->channel2->getChannelInfo();
	// $channel1 and $channel2 shares the same channel, thus only 1
	// channel should be in the persistent list.
	$this->assertEquals($channel1_info['key'], $channel2_info['key']);
	$this->assertArrayHasKey($channel1_info['key'], $plist);
	$this->assertEquals(count($plist), 1);
	$this->channel1->close();
	$this->channel2->close();
	}

	public function testPersistentChannelDifferentTarget()
	{
	$this->channel1 = new Grpc\Channel('localhost:1', []);
	$channel1_info = $this->channel1->getChannelInfo();
	$this->channel2 = new Grpc\Channel('localhost:2', []);
	$channel2_info = $this->channel1->getChannelInfo();
	$plist_info = $this->channel1->getPersistentList();
	$this->assertArrayHasKey($channel1_info['key'], $plist_info);
	$this->assertArrayHasKey($channel2_info['key'], $plist_info);
	$this->assertEquals($plist_info[$channel1_info['key']]['ref_count'], 2);
	$this->assertEquals($plist_info[$channel2_info['key']]['ref_count'], 2);
	$plist_info = $this->channel1->getPersistentList();
	$this->assertEquals(count($plist_info), 2);
	$this->channel1->close();
	$this->channel2->close();
	}

	public function testPersistentChannelSharedChannelClose()
	{
	$this->expectException(\RuntimeException::class);
	$this->expectExceptionMessage("startBatch Error. Channel is closed");
	// same underlying channel
	$this->channel1 = new Grpc\Channel('localhost:10001', [
	"grpc_target_persist_bound" => 2,
	]);
	$this->channel2 = new Grpc\Channel('localhost:10001', []);
	$this->server = new Grpc\Server([]);
	$this->port = $this->server->addHttp2Port('localhost:10001');
	$this->server->start();

	// channel2 can still be use
	$state = $this->channel2->getConnectivityState();
	$this->assertEquals(GRPC\CHANNEL_IDLE, $state);

	$call1 = new Grpc\Call($this->channel1,
	'/foo',
	Grpc\Timeval::infFuture());
	$call2 = new Grpc\Call($this->channel2,
	'/foo',
	Grpc\Timeval::infFuture());
	$call3 = new Grpc\Call($this->channel1,
	'/foo',
	Grpc\Timeval::infFuture());
	$call4 = new Grpc\Call($this->channel2,
	'/foo',
	Grpc\Timeval::infFuture());
	$batch = [
	Grpc\OP_SEND_INITIAL_METADATA => [],
	];

	$result = $call1->startBatch($batch);
	$this->assertTrue($result->send_metadata);
	$result = $call2->startBatch($batch);
	$this->assertTrue($result->send_metadata);

	$this->channel1->close();
	// After closing channel1, channel2 can still be use
	$result = $call4->startBatch($batch);
	$this->assertTrue($result->send_metadata);
	// channel 1 is closed, it will throw an exception.
	$result = $call3->startBatch($batch);
	}

	public function testPersistentChannelTargetDefaultUpperBound()
	{
	$this->channel1 = new Grpc\Channel('localhost:10002', []);
	$channel1_info = $this->channel1->getChannelInfo();
	$this->assertEquals($channel1_info['target_upper_bound'], 1);
	$this->assertEquals($channel1_info['target_current_size'], 1);
	}

	public function testPersistentChannelTargetUpperBoundZero()
	{
	$this->channel1 = new Grpc\Channel('localhost:10002', [
	"grpc_target_persist_bound" => 0,
	]);
	// channel1 will not be persisted.
	$channel1_info = $this->channel1->getChannelInfo();
	$this->assertEquals($channel1_info['target_upper_bound'], 0);
	$this->assertEquals($channel1_info['target_current_size'], 0);
	$plist_info = $this->channel1->getPersistentList();
	$this->assertEquals(0, count($plist_info));
	}

	public function testPersistentChannelTargetUpperBoundNotZero()
	{
	$this->channel1 = new Grpc\Channel('localhost:10003', [
	"grpc_target_persist_bound" => 3,
	]);
	$channel1_info = $this->channel1->getChannelInfo();
	$this->assertEquals($channel1_info['target_upper_bound'], 3);
	$this->assertEquals($channel1_info['target_current_size'], 1);

	// The upper bound should not be changed
	$this->channel2 = new Grpc\Channel('localhost:10003', []);
	$channel2_info = $this->channel2->getChannelInfo();
	$this->assertEquals($channel2_info['target_upper_bound'], 3);
	$this->assertEquals($channel2_info['target_current_size'], 1);

	// The upper bound should not be changed
	$channel_credentials = Grpc\ChannelCredentials::createSsl(null, null,
	null);
	$this->channel3 = new Grpc\Channel('localhost:10003',
	['credentials' => $channel_credentials]);
	$channel3_info = $this->channel3->getChannelInfo();
	$this->assertEquals($channel3_info['target_upper_bound'], 3);
	$this->assertEquals($channel3_info['target_current_size'], 2);

	// The upper bound should not be changed
	$this->channel4 = new Grpc\Channel('localhost:10003', [
	"grpc_target_persist_bound" => 5,
	]);
	$channel4_info = $this->channel4->getChannelInfo();
	$this->assertEquals($channel4_info['target_upper_bound'], 5);
	$this->assertEquals($channel4_info['target_current_size'], 2);
	}

	public function testPersistentChannelDefaultOutBound1()
	{
	$this->channel1 = new Grpc\Channel('localhost:10004', []);
	// Make channel1 not IDLE.
	$this->channel1->getConnectivityState(true);
	$this->waitUntilNotIdle($this->channel1);
	$channel1_info = $this->channel1->getChannelInfo();
	$this->assertConnecting($channel1_info['connectivity_status']);

	// Since channel1 is CONNECTING, channel 2 will not be persisted
	$channel_credentials = Grpc\ChannelCredentials::createSsl(null, null,
	null);
	$this->channel2 = new Grpc\Channel('localhost:10004',
	['credentials' => $channel_credentials]);
	$channel2_info = $this->channel2->getChannelInfo();
	$this->assertEquals(GRPC\CHANNEL_IDLE, $channel2_info['connectivity_status']);

	// By default, target 'localhost:10011' only persist one channel.
	// Since channel1 is not Idle channel2 will not be persisted.
	$plist_info = $this->channel1->getPersistentList();
	$this->assertEquals(1, count($plist_info));
	$this->assertArrayHasKey($channel1_info['key'], $plist_info);
	$this->assertArrayNotHasKey($channel2_info['key'], $plist_info);
	}

	public function testPersistentChannelDefaultOutBound2()
	{
	$this->channel1 = new Grpc\Channel('localhost:10005', []);
	$channel1_info = $this->channel1->getChannelInfo();
	$this->assertEquals(GRPC\CHANNEL_IDLE, $channel1_info['connectivity_status']);

	// Although channel1 is IDLE, channel1 still has reference to the underline
	// gRPC channel. channel2 will not be persisted
	$channel_credentials = Grpc\ChannelCredentials::createSsl(null, null,
	null);
	$this->channel2 = new Grpc\Channel('localhost:10005',
	['credentials' => $channel_credentials]);
	$channel2_info = $this->channel2->getChannelInfo();
	$this->assertEquals(GRPC\CHANNEL_IDLE, $channel2_info['connectivity_status']);

	// By default, target 'localhost:10011' only persist one channel.
	// Since channel1 Idle, channel2 will be persisted.
	$plist_info = $this->channel1->getPersistentList();
	$this->assertEquals(1, count($plist_info));
	$this->assertArrayHasKey($channel1_info['key'], $plist_info);
	$this->assertArrayNotHasKey($channel2_info['key'], $plist_info);
	}

	public function testPersistentChannelDefaultOutBound3()
	{
	$this->channel1 = new Grpc\Channel('localhost:10006', []);
	$channel1_info = $this->channel1->getChannelInfo();
	$this->assertEquals(GRPC\CHANNEL_IDLE, $channel1_info['connectivity_status']);

	$this->channel1->close();
	// channel1 is closed, no reference holds to the underline channel.
	// channel2 can be persisted.
	$channel_credentials = Grpc\ChannelCredentials::createSsl(null, null,
	null);
	$this->channel2 = new Grpc\Channel('localhost:10006',
	['credentials' => $channel_credentials]);
	$channel2_info = $this->channel2->getChannelInfo();
	$this->assertEquals(GRPC\CHANNEL_IDLE, $channel2_info['connectivity_status']);

	// By default, target 'localhost:10011' only persist one channel.
	// Since channel1 Idle, channel2 will be persisted.
	$plist_info = $this->channel2->getPersistentList();
	$this->assertEquals(1, count($plist_info));
	$this->assertArrayHasKey($channel2_info['key'], $plist_info);
	$this->assertArrayNotHasKey($channel1_info['key'], $plist_info);
	}

	public function testPersistentChannelTwoUpperBound()
	{
	$this->channel1 = new Grpc\Channel('localhost:10007', [
	"grpc_target_persist_bound" => 2,
	]);
	$channel1_info = $this->channel1->getChannelInfo();
	$this->assertEquals(GRPC\CHANNEL_IDLE, $channel1_info['connectivity_status']);

	// Since channel1 is IDLE, channel 1 will be deleted
	$channel_credentials = Grpc\ChannelCredentials::createSsl(null, null,
	null);
	$this->channel2 = new Grpc\Channel('localhost:10007',
	['credentials' => $channel_credentials]);
	$channel2_info = $this->channel2->getChannelInfo();
	$this->assertEquals(GRPC\CHANNEL_IDLE, $channel2_info['connectivity_status']);

	$plist_info = $this->channel1->getPersistentList();
	$this->assertEquals(2, count($plist_info));
	$this->assertArrayHasKey($channel1_info['key'], $plist_info);
	$this->assertArrayHasKey($channel2_info['key'], $plist_info);
	}

	public function testPersistentChannelTwoUpperBoundOutBound1()
	{
	$this->channel1 = new Grpc\Channel('localhost:10011', [
	"grpc_target_persist_bound" => 2,
	]);
	$channel1_info = $this->channel1->getChannelInfo();

	$channel_credentials = Grpc\ChannelCredentials::createSsl(null, null,
	null);
	$this->channel2 = new Grpc\Channel('localhost:10011',
	['credentials' => $channel_credentials]);
	$channel2_info = $this->channel2->getChannelInfo();

	// Close channel1, so that new channel can be persisted.
	$this->channel1->close();

	$channel_credentials = Grpc\ChannelCredentials::createSsl("a", null,
	null);
	$this->channel3 = new Grpc\Channel('localhost:10011',
	['credentials' => $channel_credentials]);
	$channel3_info = $this->channel3->getChannelInfo();

	$plist_info = $this->channel1->getPersistentList();
	$this->assertEquals(2, count($plist_info));
	$this->assertArrayNotHasKey($channel1_info['key'], $plist_info);
	$this->assertArrayHasKey($channel2_info['key'], $plist_info);
	$this->assertArrayHasKey($channel3_info['key'], $plist_info);
	}

	public function testPersistentChannelTwoUpperBoundOutBound2()
	{
	$this->channel1 = new Grpc\Channel('localhost:10012', [
	"grpc_target_persist_bound" => 2,
	]);
	$channel1_info = $this->channel1->getChannelInfo();

	$channel_credentials = Grpc\ChannelCredentials::createSsl(null, null,
	null);
	$this->channel2 = new Grpc\Channel('localhost:10012',
	['credentials' => $channel_credentials]);
	$channel2_info = $this->channel2->getChannelInfo();

	// Close channel2, so that new channel can be persisted.
	$this->channel2->close();

	$channel_credentials = Grpc\ChannelCredentials::createSsl("a", null,
	null);
	$this->channel3 = new Grpc\Channel('localhost:10012',
	['credentials' => $channel_credentials]);
	$channel3_info = $this->channel3->getChannelInfo();

	$plist_info = $this->channel1->getPersistentList();
	$this->assertEquals(2, count($plist_info));
	$this->assertArrayHasKey($channel1_info['key'], $plist_info);
	$this->assertArrayNotHasKey($channel2_info['key'], $plist_info);
	$this->assertArrayHasKey($channel3_info['key'], $plist_info);
	}

	public function testPersistentChannelTwoUpperBoundOutBound3()
	{
	$this->channel1 = new Grpc\Channel('localhost:10013', [
	"grpc_target_persist_bound" => 2,
	]);
	$channel1_info = $this->channel1->getChannelInfo();

	$channel_credentials = Grpc\ChannelCredentials::createSsl(null, null,
	null);
	$this->channel2 = new Grpc\Channel('localhost:10013',
	['credentials' => $channel_credentials]);
	$this->channel2->getConnectivityState(true);
	$this->waitUntilNotIdle($this->channel2);
	$channel2_info = $this->channel2->getChannelInfo();
	$this->assertConnecting($channel2_info['connectivity_status']);

	// Only one channel will be deleted
	$this->channel1->close();
	$this->channel2->close();

	$channel_credentials = Grpc\ChannelCredentials::createSsl("a", null,
	null);
	$this->channel3 = new Grpc\Channel('localhost:10013',
	['credentials' => $channel_credentials]);
	$channel3_info = $this->channel3->getChannelInfo();

	// Only the Idle Channel will be deleted
	$plist_info = $this->channel1->getPersistentList();
	$this->assertEquals(2, count($plist_info));
	$this->assertArrayNotHasKey($channel1_info['key'], $plist_info);
	$this->assertArrayHasKey($channel2_info['key'], $plist_info);
	$this->assertArrayHasKey($channel3_info['key'], $plist_info);
	}

	public function testPersistentChannelTwoUpperBoundOutBound4()
	{
	$this->channel1 = new Grpc\Channel('localhost:10014', [
	"grpc_target_persist_bound" => 2,
	]);
	$this->channel1->getConnectivityState(true);
	$this->waitUntilNotIdle($this->channel1);
	$channel1_info = $this->channel1->getChannelInfo();
	$this->assertConnecting($channel1_info['connectivity_status']);

	$channel_credentials = Grpc\ChannelCredentials::createSsl(null, null,
	null);
	$this->channel2 = new Grpc\Channel('localhost:10014',
	['credentials' => $channel_credentials]);
	$this->channel2->getConnectivityState(true);
	$this->waitUntilNotIdle($this->channel2);
	$channel2_info = $this->channel2->getChannelInfo();
	$this->assertConnecting($channel2_info['connectivity_status']);

	$channel_credentials = Grpc\ChannelCredentials::createSsl("a", null,
	null);
	$this->channel3 = new Grpc\Channel('localhost:10014',
	['credentials' => $channel_credentials]);
	$channel3_info = $this->channel3->getChannelInfo();

	// Channel3 will not be persisted
	$plist_info = $this->channel1->getPersistentList();
	$this->assertEquals(2, count($plist_info));
	$this->assertArrayHasKey($channel1_info['key'], $plist_info);
	$this->assertArrayHasKey($channel2_info['key'], $plist_info);
	$this->assertArrayNotHasKey($channel3_info['key'], $plist_info);
	}
	}