public class EmptyJsonLenientConverterFactory extends Converter.Factory {

    private final GsonConverterFactory mGsonConverterFactory;       // 1

    public EmptyJsonLenientConverterFactory(
            GsonConverterFactory gsonConverterFactory) {
        mGsonConverterFactory = gsonConverterFactory;
    }

    @Override
    public Converter<?, RequestBody> requestBodyConverter(Type type,
            Annotation[] parameterAnnotations,
            Annotation[] methodAnnotations,
            Retrofit retrofit) {
        return mGsonConverterFactory.requestBodyConverter(type,     // 2
                parameterAnnotations, methodAnnotations, retrofit);
    }

    @Override
    public Converter<ResponseBody, ?> responseBodyConverter(Type type,
            Annotation[] annotations,
            Retrofit retrofit) {
        final Converter<ResponseBody, ?> delegateConverter =        // 3
                mGsonConverterFactory.responseBodyConverter(type,
                        annotations, retrofit);
        return value -> {
            try {
                return delegateConverter.convert(value);            // 4
            } catch (EOFException e) {
                // just return null
                return null;                                        // 5
            }
        };
    }
}

public class EmptyJsonLenientConverterFactoryTest {

    private Retrofit mRetrofit;
    private EmptyJsonLenientConverterFactory mFactory;

    @Before
    public void setUp() {
        mRetrofit = new Retrofit.Builder()
                .baseUrl(SERVER_ENDPOINT)
                .build();
        mFactory = new EmptyJsonLenientConverterFactory(
                GsonConverterFactory.create());
    }

    @Test
    public void convertNormalJson() 
            throws IOException {
        // 验证正常 JSON 能正确解析
    }

    @Test(expected = EOFException.class)
    public void gsonConverterFailOnEmptyJson() 
            throws IOException {
        // 验证 GsonConverter 无法处理空字符串
    }

    @Test
    public void convertEmptyJson() 
            throws IOException {
        // 验证我们的 converter 可以处理空字符串
    }
}

public static ResponseBody stringBody(String body) {        // 1
    return ResponseBody.create(
            MediaType.parse("application/json"), body);
}

@Test
public void convertNormalJson()
        throws IOException {
    String normalJson = "{\"request\":\"req\","
            + "\"errcode\":123,"
            + "\"errmsg\":\"qw\"}";
    Converter<ResponseBody, ?> converter =
            mFactory.responseBodyConverter(YLApiError.class,
                    EMPTY_ANNOTATIONS, mRetrofit);
    Object response = converter.convert(stringBody(normalJson));
    assertTrue(response instanceof YLApiError);
    YLApiError apiError = (YLApiError) response;
    assertEquals(123, apiError.getErrcode());
}

@Test(expected = EOFException.class)                    // 1
public void gsonConverterFailOnEmptyJson()
        throws IOException {
    String emptyJson = "";
    Converter<ResponseBody, ?> converter =
            GsonConverterFactory.create().responseBodyConverter(
                    YLApiError.class, EMPTY_ANNOTATIONS, mRetrofit);
    converter.convert(stringBody(emptyJson));
}

@Test
public void convertEmptyJson()
        throws IOException {
    String emptyJson = "";
    Converter<ResponseBody, ?> converter =
            mFactory.responseBodyConverter(YLApiError.class,
                    EMPTY_ANNOTATIONS, mRetrofit);
    Object response = converter.convert(stringBody(emptyJson));
    assertNull(response);
}

public class YLApiErrorAwareConverterFactory extends Converter.Factory {

    private final Converter.Factory mDelegateFactory;           // 1

    public YLApiErrorAwareConverterFactory(
            Converter.Factory delegateFactory) {
        mDelegateFactory = delegateFactory;
    }

    @Override
    public Converter<?, RequestBody> requestBodyConverter(Type type,
            Annotation[] parameterAnnotations,
            Annotation[] methodAnnotations,
            Retrofit retrofit) {
        return mDelegateFactory
                .requestBodyConverter(type, parameterAnnotations,
                        methodAnnotations, retrofit);
    }

    @Override
    public Converter<ResponseBody, ?> responseBodyConverter(Type type,
            Annotation[] annotations,
            Retrofit retrofit) {
        final Converter<ResponseBody, ?> apiErrorConverter =    // 2
                mDelegateFactory.responseBodyConverter(YLApiError.class,
                        annotations, retrofit);
        final Converter<ResponseBody, ?> delegateConverter =
                mDelegateFactory.responseBodyConverter(type,
                        annotations, retrofit);
        return value -> {
            ResponseBody clone = ResponseBody.create(           // 3
                    value.contentType(),
                    value.contentLength(),
                    value.source().buffer().clone());
            Object apiError = apiErrorConverter.convert(clone);
            if (apiError instanceof YLApiError
                    && ((YLApiError) apiError).isApiError()) {
                throw (YLApiError) apiError;                    // 4
            }
            return delegateConverter.convert(value);
        };
    }
}

public class YLApiErrorAwareConverterFactoryTest {

    private Retrofit mRetrofit;
    private YLApiErrorAwareConverterFactory mFactory;

    @Before
    public void setUp() {
        mRetrofit = new Retrofit.Builder()
                .baseUrl(SERVER_ENDPOINT)
                .build();
        EmptyJsonLenientConverterFactory delegate =
                new EmptyJsonLenientConverterFactory(
                        GsonConverterFactory.create());
        mFactory = new YLApiErrorAwareConverterFactory(delegate);
    }

    @Test
    public void nonApiError() throws IOException {
        // 验证解析正常数据
    }

    @Test
    public void apiError() throws IOException {
        // 验证解析 API Error
    }

    @Test
    public void emptyJson() throws IOException {
        // 验证空字符串不会被解析为 API Error
    }
}

@Test
public void apiError() throws IOException {
    String errorString = "{\"request\":\"req\"," 
            + "\"errcode\":123," 
            + "\"errmsg\":\"qw\"}";
    Converter<ResponseBody, ?> converter = 
            mFactory.responseBodyConverter(
                    Dummy.class, EMPTY_ANNOTATIONS, mRetrofit);
    try {
        converter.convert(stringBody(errorString));
        assertTrue(false);
    } catch (YLApiError apiError) {
        assertEquals(123, apiError.getErrcode());       // 1
    }
}

public interface UserInfoModel {
  long uid();
  @NonNull
  String username();
  @Nullable
  String avatar_url();
}

public interface FriendInfoModel {
  long uid();
  int starred();
  @Nullable
  String friend_remark();
}

interface RelationshipInfo {
    boolean is_friend();
}

interface CredentialInfo {
    @Nullable
    String phone();
    @Nullable
    String im_password();
    @Nullable
    String token();
}

@AutoValue
abstract class ApiUser implements UserInfoModel, 
    RelationshipInfo, FriendInfoModel, CredentialInfo {

    public static TypeAdapter<ApiUser> typeAdapter(final Gson gson) {
        return new AutoValue_ApiUser.GsonTypeAdapter(gson);
    }
}

@AutoValue
public abstract class NonFriend implements UserInfoModel, Parcelable {

    public static NonFriend createFrom(ApiUser user) {
        // ...
    }
}

@AutoValue
public abstract class FriendInfo implements FriendInfoModel, Parcelable {

    public static Builder builder() {
        return new AutoValue_FriendInfo.Builder();
    }

    @AutoValue.Builder
    public abstract static class Builder {
        // ...
    }
}

@AutoValue
public abstract class Friend implements UserInfoModel, Parcelable {

    public abstract FriendInfo friendInfo();

    public static Friend createFrom(ApiUser user) {
        // ...
    }
    
    static Friend compose(UserInfoModel user, FriendInfo friendInfo) {
        // ...
    }
}

@AutoValue
public abstract class Self implements UserInfoModel, 
    CredentialInfo, Parcelable {

    public static Self createFrom(ApiUser user) {
        // ...
    }
}

interface UserInfoApi {

    @GET("/users/{uid}")
    Observable<ApiUser> userInfo(@Path("uid") long uid);
}

public class UserRepo {
    // ...

    public Observable<UserInfoModel> otherUserInfo(long uid, boolean refresh) {
        Observable<UserInfoModel> local = Observable.defer(() -> {
            List<UserInfoModel> cached = mUserDbAccessor.get(uid);  // 1
            if (cached.isEmpty()) {
                return Observable.empty();
            } else {
                List<FriendInfo> friendInfoList = 
                        mFriendDbAccessor.get(uid);                 // 2
                if (friendInfoList.isEmpty()) {
                    return Observable.just(
                            NonFriend.wrap(cached.get(0)));         // 3
                }
                return Observable.just(Friend.compose(
                        cached.get(0), friendInfoList.get(0)));     // 4
            }
        });
        Observable<UserInfoModel> remote = mUserInfoApi
                .userInfo(uid)
                .map(API_USER_MAPPER)                               // 5
                .doOnNext(mUserSaver);
        Observable<UserInfoModel> combined = 
                Observable.concat(local, remote);                   // 6
        if (!refresh) {
            return combined.first();                                // 7
        }
        return combined;
    }
    
    static final Func1<ApiUser, UserInfoModel> API_USER_MAPPER = apiUser -> {
        if (apiUser.is_friend()) {                                  // 8
            return Friend.createFrom(apiUser);
        } else {
            return NonFriend.createFrom(apiUser);
        }
    };

    private final Action1<UserInfoModel> mUserSaver = user -> {
        if (user instanceof Friend) {                               // 9
            mFriendDbAccessor.put(((Friend) user).friendInfo());
        }
        mUserDbAccessor.put(user);
    };
}

public class UserRepoTest {
    // ...

    @Test
    public void otherUserInfoNotRefreshCacheMissNonFriend() {
        // 不刷新本地缓存、缓存缺失、对方不是好友的情形
    }

    @Test
    public void otherUserInfoNotRefreshCacheHitNonFriend() {
        // 不刷新本地缓存、缓存命中、对方不是好友的情形
    }

    @Test
    public void otherUserInfoNotRefreshCacheHitFriend() {
        // 不刷新本地缓存、缓存命中、对方是好友的情形
    }

    @Test
    public void otherUserInfoRefreshCacheMissFriend() {
        // 刷新本地缓存、缓存缺失、对方是好友的情形
    }

    @Test
    public void otherUserInfoRefreshCacheHitFriend() {
        // 刷新本地缓存、缓存命中、对方是好友的情形
    }
}

@Test
public void otherUserInfoRefreshCacheHitFriend() {
    long uid = 1905378617;
    final ApiUser user = mGson.fromJson(MOCK_FRIEND, ApiUser.class);// 1
    final FriendInfo friendInfo = FriendInfo.builder()
            .uid(user.uid())
            .friend_remark(user.friend_remark())
            .starred(user.starred())
            .build();
    final Friend friend = Friend.compose(user, friendInfo);
    final NonFriend nonFriend = NonFriend.createFrom(user);
    when(mUserDbAccessor.get(uid))
            .thenReturn(Collections.singletonList(nonFriend));      // 2
    when(mFriendDbAccessor.get(uid))
            .thenReturn(Collections.singletonList(friendInfo));
    when(mUserInfoApi.userInfo(uid))
            .thenReturn(Observable.just(user));

    TestSubscriber<UserInfoModel> testSubscriber = new TestSubscriber<>();
    mUserRepo.otherUserInfo(uid, true).subscribe(testSubscriber);
    testSubscriber.awaitTerminalEvent();

    testSubscriber.assertNoErrors();
    testSubscriber.assertCompleted();
    testSubscriber.assertValues(friend, friend);                    // 3

    // 查询 db
    verify(mFriendDbAccessor, times(1)).get(uid);                   // 4
    verify(mUserDbAccessor, times(1)).get(uid);
    // 请求 api
    verify(mUserInfoApi, times(1)).userInfo(uid);                   // 5
    verifyNoMoreInteractions(mUserInfoApi);
    // 保存到 db
    verify(mFriendDbAccessor, times(1)).put(friendInfo);            // 6
    verifyNoMoreInteractions(mFriendDbAccessor);
    verify(mUserDbAccessor, times(1)).put(friend);
    verifyNoMoreInteractions(mUserDbAccessor);
}