anchor.diff:        final rs1 = await client2.listPackageLikes();
         expect(rs1.likedPackages.isEmpty, true);
   
  -      final rs2 = await client.likePackage(hydrogen.packageName);
  -      expect(rs2.package, hydrogen.packageName);
  +      final rs2 = await client.likePackage(pkg1);
  +      expect(rs2.package, pkg1);
         expect(rs2.liked, true);
   
         final rs3 = await client2.listPackageLikes();
         expect(rs3.likedPackages.isEmpty, true);
       });
   
  -    testWithServices('Package likes property is incremented/decremented.',
  -        () async {
  -      final client = createPubApiClient(authToken: hansUser.userId);
  -      final client2 = createPubApiClient(authToken: joeUser.userId);
  +    testWithProfile('Package likes property is incremented/decremented.',
  +        fn: () async {
  +      final client = createPubApiClient(authToken: userAtPubDevAuthToken);
  +      final client2 = createPubApiClient(authToken: adminAtPubDevAuthToken);
   
  -      final rs = await client.getPackageLikes(hydrogen.packageName);
  +      final rs = await client.getPackageLikes(pkg1);
         expect(rs.likes, 0);
  -      final rs2 = await client2.getPackageLikes(hydrogen.packageName);
  +      final rs2 = await client2.getPackageLikes(pkg1);
         expect(rs2.likes, 0);
   
  -      await client.likePackage(hydrogen.packageName);
  +      await client.likePackage(pkg1);
   
  -      final rs3 = await client.getPackageLikes(hydrogen.packageName);
  +      final rs3 = await client.getPackageLikes(pkg1);
         expect(rs3.likes, 1);
  -      final rs4 = await client2.getPackageLikes(hydrogen.packageName);
  +      final rs4 = await client2.getPackageLikes(pkg1);
         expect(rs4.likes, 1);
   
  -      await client2.likePackage(hydrogen.packageName);
  +      await client2.likePackage(pkg1);
   
  -      final rs5 = await client.getPackageLikes(hydrogen.packageName);
  +      final rs5 = await client.getPackageLikes(pkg1);
         expect(rs5.likes, 2);
  -      final rs6 = await client2.getPackageLikes(hydrogen.packageName);
  +      final rs6 = await client2.getPackageLikes(pkg1);
         expect(rs6.likes, 2);
   
  -      await client.unlikePackage(hydrogen.packageName);
  +      await client.unlikePackage(pkg1);
   
  -      final rs7 = await client.getPackageLikes(hydrogen.packageName);
  +      final rs7 = await client.getPackageLikes(pkg1);
         expect(rs7.likes, 1);
  -      final rs8 = await client2.getPackageLikes(hydrogen.packageName);
  +      final rs8 = await client2.getPackageLikes(pkg1);
         expect(rs8.likes, 1);
   
         /// Unliking already unliked package doesn't cause decrement
  -      await client.unlikePackage(hydrogen.packageName);
  +      await client.unlikePackage(pkg1);
   
  -      final rs9 = await client.getPackageLikes(hydrogen.packageName);
  +      final rs9 = await client.getPackageLikes(pkg1);
         expect(rs9.likes, 1);
  -      final rs10 = await client2.getPackageLikes(hydrogen.packageName);
  +      final rs10 = await client2.getPackageLikes(pkg1);
         expect(rs10.likes, 1);
   
  -      await client2.unlikePackage(hydrogen.packageName);
  +      await client2.unlikePackage(pkg1);
   
  -      final rs11 = await client.getPackageLikes(hydrogen.packageName);
  +      final rs11 = await client.getPackageLikes(pkg1);
         expect(rs11.likes, 0);
  -      final rs12 = await client2.getPackageLikes(hydrogen.packageName);
  +      final rs12 = await client2.getPackageLikes(pkg1);
         expect(rs12.likes, 0);
       });
   
  -    testWithServices('Get number of likes for non-existing package.', () async {
  -      final client = createPubApiClient(authToken: hansUser.userId);
  +    testWithProfile('Get number of likes for non-existing package.',
  +        fn: () async {
  +      final client = createPubApiClient(authToken: userAtPubDevAuthToken);
         await expectApiException(client.getPackageLikes('non-existing_package'),
             status: 404);
       });
   
  -    testWithServices(
  +    testWithProfile(
           'Get number of likes for client without authorization header.',
  -        () async {
  +        fn: () async {
         final client = createPubApiClient();
  -      final rs = await client.getPackageLikes(hydrogen.packageName);
  +      final rs = await client.getPackageLikes(pkg1);
         expect(rs.likes, 0);
   
         final authenticatedClient =
  -          createPubApiClient(authToken: hansUser.userId);
  -      await authenticatedClient.likePackage(hydrogen.packageName);
  +          createPubApiClient(authToken: userAtPubDevAuthToken);
  +      await authenticatedClient.likePackage(pkg1);
   
  -      final rs1 = await client.getPackageLikes(hydrogen.packageName);
  +      final rs1 = await client.getPackageLikes(pkg1);
         expect(rs1.likes, 1);
       });
     });
  
positive.code:       expect(rs4.likedPackages[0].liked, true);
        expect(rs4.likedPackages[1].liked, true);
  
        await client.unlikePackage(hydrogen.packageName);
  
        final rs5 = await client.getLikePackage(hydrogen.packageName);
        expect(rs5.package, hydrogen.packageName);
        expect(rs5.liked, false);
  
        final rs6 = await client.listPackageLikes();
        expect(rs6.likedPackages.length, 1);
        expect(rs6.likedPackages[0].package, helium.packageName);
      });
  
      testWithServices('Unlike non-existing package', () async {
        final client = createPubApiClient(authToken: hansUser.userId);
        await expectApiException(client.unlikePackage('non-existing_package'),
            status: 404);
      });
  
      testWithServices('Two users don\'t affect each other\'s package likes.',
          () async {
        final client = createPubApiClient(authToken: hansUser.userId);
        final client2 = createPubApiClient(authToken: joeUser.userId);
  
        final rs = await client.listPackageLikes();
        expect(rs.likedPackages.isEmpty, true);
  
negative.code: 
  void main() {
    group('/api/account/likes', () {
      final pkg1 = 'oxygen';
      final pkg2 = 'neon';
  
      testWithProfile('Like package', fn: () async {
        final client = createPubApiClient(authToken: userAtPubDevAuthToken);
        final rs = await client.getLikePackage(pkg1);
        expect(rs.package, pkg1);
        expect(rs.liked, false);
  
        final rs2 = await client.likePackage(pkg1);
        expect(rs2.package, pkg1);
        expect(rs2.liked, true);
  
        final rs3 = await client.getLikePackage(pkg1);
        expect(rs3.package, pkg1);
        expect(rs3.liked, true);
      });
  
      testWithProfile('Like already liked package', fn: () async {
        final client = createPubApiClient(authToken: userAtPubDevAuthToken);
  
        final rs = await client.likePackage(pkg1);
        expect(rs.package, pkg1);
        expect(rs.liked, true);
  
        final rs2 = await client.likePackage(pkg1);
        expect(rs2.package, pkg1);
        expect(rs2.liked, true);
  
        final rs3 = await client.getLikePackage(pkg1);
        expect(rs3.package, pkg1);
        expect(rs3.liked, true);
      });
  
      testWithProfile('Like non-existing package', fn: () async {
        final client = createPubApiClient(authToken: userAtPubDevAuthToken);
        await expectApiException(client.likePackage('non-existing_package'),
            status: 404);
      });
  
      testWithProfile('List package likes', fn: () async {
        final client = createPubApiClient(authToken: userAtPubDevAuthToken);
        final rs = await client.listPackageLikes();
        expect(rs.likedPackages.isEmpty, true);
  
        final rs2 = await client.likePackage(pkg1);
        expect(rs2.package, pkg1);
        expect(rs2.liked, true);
  
        final rs3 = await client.likePackage(pkg2);
        expect(rs3.package, pkg2);
        expect(rs3.liked, true);
  
        final rs4 = await client.listPackageLikes();
        expect(rs4.likedPackages.length, 2);
        expect(rs4.likedPackages.map((e) => e.package), contains(pkg1));
        expect(rs4.likedPackages.map((e) => e.package), contains(pkg2));
        expect(rs4.likedPackages[0].liked, true);
        expect(rs4.likedPackages[1].liked, true);
      });
  
      testWithProfile('Unlike package', fn: () async {
        final client = createPubApiClient(authToken: userAtPubDevAuthToken);
        final rs = await client.listPackageLikes();
        expect(rs.likedPackages.isEmpty, true);
  
        final rs2 = await client.likePackage(pkg1);
        expect(rs2.package, pkg1);
        expect(rs2.liked, true);
  
        final rs3 = await client.likePackage(pkg2);
        expect(rs3.package, pkg2);
        expect(rs3.liked, true);
  
        final rs4 = await client.listPackageLikes();
  